a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
HiggsThObservables.cpp
Go to the documentation of this file.
1/*
2 * Copyright (C) 2019 HEPfit Collaboration
3 *
4 *
5 * For the licensing terms see doc/COPYING.
6 */
7
9#include "NPbase.h"
10
11muggH::muggH(const StandardModel& SM_i, const double sqrt_s_i)
12: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13{
14 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
15 throw std::runtime_error("muggH called with a class whose parent is not NPbase");
16}
17
19{
20 return myNPbase->muggH(sqrt_s);
21}
22
23muVBF::muVBF(const StandardModel& SM_i, const double sqrt_s_i)
24: ThObservable(SM_i), sqrt_s(sqrt_s_i)
25{
26 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
27 throw std::runtime_error("muVBF called with a class whose parent is not NPbase");
28
29}
30
32{
33 return myNPbase->muVBF(sqrt_s);
34}
35
36muVBFgamma::muVBFgamma(const StandardModel& SM_i, const double sqrt_s_i)
37: ThObservable(SM_i), sqrt_s(sqrt_s_i)
38{
39 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
40 throw std::runtime_error("muVBFgamma called with a class whose parent is not NPbase");
41
42}
43
45{
46 return myNPbase->muVBFgamma(sqrt_s);
47}
48
49mueeWBF::mueeWBF(const StandardModel& SM_i, const double sqrt_s_i)
50: ThObservable(SM_i), sqrt_s(sqrt_s_i)
51{
52 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
53 throw std::runtime_error("mueeWBF called with a class whose parent is not NPbase");
54
55}
56
58{
59 return myNPbase->mueeWBF(sqrt_s);
60}
61
62mueeWBFPol::mueeWBFPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
63: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
64{
65 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
66 throw std::runtime_error("mueeWBFPol called with a class whose parent is not NPbase");
67}
68
70{
72}
73
74mueeHvv::mueeHvv(const StandardModel& SM_i, const double sqrt_s_i)
75: ThObservable(SM_i), sqrt_s(sqrt_s_i)
76{
77 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
78 throw std::runtime_error("mueeHvv called with a class whose parent is not NPbase");
79}
80
82{
83 return myNPbase->mueeHvv(sqrt_s);
84}
85
86mueeHvvPol::mueeHvvPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
87: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
88{
89 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
90 throw std::runtime_error("mueeHvvPol called with a class whose parent is not NPbase");
91}
92
94{
96}
97
98mueeZBF::mueeZBF(const StandardModel& SM_i, const double sqrt_s_i)
99: ThObservable(SM_i), sqrt_s(sqrt_s_i)
100{
101 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
102 throw std::runtime_error("mueeZBF called with a class whose parent is not NPbase");
103
104}
105
107{
108 return myNPbase->mueeZBF(sqrt_s);
109}
110
111mueeZBFPol::mueeZBFPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
112: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
113{
114 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
115 throw std::runtime_error("mueeZBFPol called with a class whose parent is not NPbase");
116}
117
119{
121}
122
123muepWBF::muepWBF(const StandardModel& SM_i, const double sqrt_s_i)
124: ThObservable(SM_i), sqrt_s(sqrt_s_i)
125{
126 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
127 throw std::runtime_error("muepWBF called with a class whose parent is not NPbase");
128
129}
130
132{
133 return myNPbase->muepWBF(sqrt_s);
134}
135
136muWH::muWH(const StandardModel& SM_i, const double sqrt_s_i)
137: ThObservable(SM_i), sqrt_s(sqrt_s_i)
138{
139 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
140 throw std::runtime_error("muWH called with a class whose parent is not NPbase");
141}
142
144{
145 return myNPbase->muWH(sqrt_s);
146}
147
148muWHpT250::muWHpT250(const StandardModel& SM_i, const double sqrt_s_i)
149: ThObservable(SM_i), sqrt_s(sqrt_s_i)
150{
151 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
152 throw std::runtime_error("muWHpT250 called with a class whose parent is not NPbase");
153}
154
156{
157 return myNPbase->muWHpT250(sqrt_s);
158}
159
160muepZBF::muepZBF(const StandardModel& SM_i, const double sqrt_s_i)
161: ThObservable(SM_i), sqrt_s(sqrt_s_i)
162{
163 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
164 throw std::runtime_error("muepZBF called with a class whose parent is not NPbase");
165
166}
167
169{
170 return myNPbase->muepZBF(sqrt_s);
171}
172
173muZH::muZH(const StandardModel& SM_i, const double sqrt_s_i)
174: ThObservable(SM_i), sqrt_s(sqrt_s_i)
175{
176 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
177 throw std::runtime_error("muZH called with a class whose parent is not NPbase");
178}
179
181{
182 return myNPbase->muZH(sqrt_s);
183}
184
185muZHpT250::muZHpT250(const StandardModel& SM_i, const double sqrt_s_i)
186: ThObservable(SM_i), sqrt_s(sqrt_s_i)
187{
188 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
189 throw std::runtime_error("muZHpT250 called with a class whose parent is not NPbase");
190}
191
193{
194 return myNPbase->muZHpT250(sqrt_s);
195}
196
197
198mueeZHGen::mueeZHGen(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
199: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
200{
201 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
202 throw std::runtime_error("mueeZHGen called with a class whose parent is not NPbase");
203}
204
206{
208}
209
210
211mueeZH::mueeZH(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
212: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
213{
214 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
215 throw std::runtime_error("mueeZH called with a class whose parent is not NPbase");
216}
217
219{
221}
222
223mueeZllH::mueeZllH(const StandardModel& SM_i, const double sqrt_s_i)
224: ThObservable(SM_i), sqrt_s(sqrt_s_i)
225{
226 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
227 throw std::runtime_error("mueeZllH called with a class whose parent is not NPbase");
228}
229
231{
232 return myNPbase->mueeZllH(sqrt_s);
233}
234
235mueeZllHPol::mueeZllHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
236: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
237{
238 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
239 throw std::runtime_error("mueeZllHPol called with a class whose parent is not NPbase");
240}
241
243{
245}
246
247mueeZqqH::mueeZqqH(const StandardModel& SM_i, const double sqrt_s_i)
248: ThObservable(SM_i), sqrt_s(sqrt_s_i)
249{
250 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
251 throw std::runtime_error("mueeZqqH called with a class whose parent is not NPbase");
252}
253
255{
256 return myNPbase->mueeZqqH(sqrt_s);
257}
258
259mueeZqqHPol::mueeZqqHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
260: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
261{
262 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
263 throw std::runtime_error("mueeZqqHPol called with a class whose parent is not NPbase");
264}
265
267{
269}
270
271
272aPsk::aPsk(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
273: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
274{
275 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
276 throw std::runtime_error("aPsk called with a class whose parent is not NPbase");
277}
278
280{
282}
283
284
285bPsk::bPsk(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
286: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
287{
288 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
289 throw std::runtime_error("bPsk called with a class whose parent is not NPbase");
290}
291
293{
295}
296
297
298muVH::muVH(const StandardModel& SM_i, const double sqrt_s_i)
299: ThObservable(SM_i), sqrt_s(sqrt_s_i)
300{
301 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
302 throw std::runtime_error("muVH called with a class whose parent is not NPbase");
303}
304
306{
307 return myNPbase->muVH(sqrt_s);
308}
309
310muVHpT250::muVHpT250(const StandardModel& SM_i, const double sqrt_s_i)
311: ThObservable(SM_i), sqrt_s(sqrt_s_i)
312{
313 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
314 throw std::runtime_error("muVHpT250 called with a class whose parent is not NPbase");
315}
316
318{
319 return myNPbase->muVHpT250(sqrt_s);
320}
321
322muVBFpVH::muVBFpVH(const StandardModel& SM_i, const double sqrt_s_i)
323: ThObservable(SM_i), sqrt_s(sqrt_s_i)
324{
325 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
326 throw std::runtime_error("muVBFpVH called with a class whose parent is not NPbase");
327}
328
330{
331 return myNPbase->muVBFpVH(sqrt_s);
332}
333
334muttH::muttH(const StandardModel& SM_i, const double sqrt_s_i)
335: ThObservable(SM_i), sqrt_s(sqrt_s_i)
336{
337 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
338 throw std::runtime_error("muttH called with a class whose parent is not NPbase");
339}
340
342{
343 return myNPbase->muttH(sqrt_s);
344}
345
346mutHq::mutHq(const StandardModel& SM_i, const double sqrt_s_i)
347: ThObservable(SM_i), sqrt_s(sqrt_s_i)
348{
349 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
350 throw std::runtime_error("mutHq called with a class whose parent is not NPbase");
351}
352
354{
355 return myNPbase->mutHq(sqrt_s);
356}
357
358muggHpttH::muggHpttH(const StandardModel& SM_i, const double sqrt_s_i)
359: ThObservable(SM_i), sqrt_s(sqrt_s_i)
360{
361 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
362 throw std::runtime_error("muggHpttH called with a class whose parent is not NPbase");
363}
364
366{
367 return myNPbase->muggHpttH(sqrt_s);
368}
369
370mueettH::mueettH(const StandardModel& SM_i, const double sqrt_s_i)
371: ThObservable(SM_i), sqrt_s(sqrt_s_i)
372{
373 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
374 throw std::runtime_error("mueettH called with a class whose parent is not NPbase");
375
376}
377
379{
380 return myNPbase->mueettH(sqrt_s);
381}
382
383mueettHPol::mueettHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
384: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
385{
386 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
387 throw std::runtime_error("mueettHPol called with a class whose parent is not NPbase");
388}
389
391{
393}
394
395mummH::mummH(const StandardModel& SM_i, const double sqrt_s_i)
396: ThObservable(SM_i), sqrt_s(sqrt_s_i)
397{
398 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
399 throw std::runtime_error("mummH called with a class whose parent is not NPbase");
400}
401
403{
404 return myNPbase->mummH(sqrt_s);
405}
406
407mummHNWA::mummHNWA(const StandardModel& SM_i, const double sqrt_s_i)
408: ThObservable(SM_i), sqrt_s(sqrt_s_i)
409{
410 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
411 throw std::runtime_error("mummHNWA called with a class whose parent is not NPbase");
412}
413
415{
416 return myNPbase->mummHNWA(sqrt_s);
417}
418
419// -----------------------------------------------------------------------------
420// Decay widths
421// -----------------------------------------------------------------------------
422
424: ThObservable(SM_i)
425{
426 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
427 throw std::runtime_error("GammaHtoggRatio called with a class whose parent is not NPbase");
428}
429
431{
432 return myNPbase->GammaHggRatio();
433}
434
436: ThObservable(SM_i)
437{
438 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
439 throw std::runtime_error("GammaHtoWWRatio called with a class whose parent is not NPbase");
440}
441
443{
444 return myNPbase->GammaHWWRatio();
445}
446
448: ThObservable(SM_i)
449{
450 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
451 throw std::runtime_error("GammaHtoZZRatio called with a class whose parent is not NPbase");
452}
453
455{
456 return myNPbase->GammaHZZRatio();
457}
458
460{
461 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
462 throw std::runtime_error("GammaHtoZgaRatio called with a class whose parent is not NPbase");
463}
464
466{
467 return myNPbase->GammaHZgaRatio();
468}
469
471{
472 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
473 throw std::runtime_error("GammaHtogagaRatio called with a class whose parent is not NPbase");
474}
475
477{
478 return myNPbase->GammaHgagaRatio();
479}
480
482{
483 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
484 throw std::runtime_error("GammaHtomumuRatio called with a class whose parent is not NPbase");
485}
486
488{
489 return myNPbase->GammaHmumuRatio();
490}
491
493{
494 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
495 throw std::runtime_error("GammaHtotautauRatio called with a class whose parent is not NPbase");
496}
497
499{
500 return myNPbase->GammaHtautauRatio();
501}
502
504{
505 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
506 throw std::runtime_error("GammaHtossRatio called with a class whose parent is not NPbase");
507}
508
510{
511 return myNPbase->GammaHssRatio();
512}
513
515{
516 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
517 throw std::runtime_error("GammaHtoccRatio called with a class whose parent is not NPbase");
518}
519
521{
522 return myNPbase->GammaHccRatio();
523}
524
526{
527 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
528 throw std::runtime_error("GammaHtobbRatio called with a class whose parent is not NPbase");
529}
530
532{
533 return myNPbase->GammaHbbRatio();
534}
535
537: ThObservable(SM_i)
538{
539 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
540 throw std::runtime_error("GammaHRatio called with a class whose parent is not NPbase");
541}
542
544{
546}
547
548// -----------------------------------------------------------------------------
549// Branching Ratios
550// -----------------------------------------------------------------------------
551
553{
554 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
555 throw std::runtime_error("BrHtoinvRatio called with a class whose parent is not NPbase");
556}
557
559{
560 return myNPbase->BrHtoinvRatio();
561}
562
564: ThObservable(SM_i)
565{
566 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
567 throw std::runtime_error("BrHinvisible called with a class whose parent is not NPbase");
568}
569
571{
572 return myNPbase->Br_H_inv();
573}
574
576: ThObservable(SM_i)
577{
578 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
579 throw std::runtime_error("BrHinvisibleNP called with a class whose parent is not NPbase");
580}
581
583{
584 return myNPbase->Br_H_inv_NP();
585}
586
588: ThObservable(SM_i)
589{
590 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
591 throw std::runtime_error("BrHexotic called with a class whose parent is not NPbase");
592}
593
595{
596 return myNPbase->Br_H_exo();
597}
598
600: ThObservable(SM_i)
601{
602 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
603 throw std::runtime_error("BrHtovisRatio called with a class whose parent is not NPbase");
604}
605
607{
608 return myNPbase->BrHvisRatio();
609}
610
612: ThObservable(SM_i)
613{
614 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
615 throw std::runtime_error("BrHtoggRatio called with a class whose parent is not NPbase");
616}
617
619{
620 return myNPbase->BrHggRatio();
621}
622
624: ThObservable(SM_i)
625{
626 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
627 throw std::runtime_error("BrHtoWWRatio called with a class whose parent is not NPbase");
628}
629
631{
632 return myNPbase->BrHWWRatio();
633}
634
636: ThObservable(SM_i)
637{
638 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
639 throw std::runtime_error("BrHtoZZRatio called with a class whose parent is not NPbase");
640}
641
643{
644 return myNPbase->BrHZZRatio();
645}
646
648: ThObservable(SM_i)
649{
650 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
651 throw std::runtime_error("BrHtoVVRatio called with a class whose parent is not NPbase");
652}
653
655{
656 return myNPbase->BrHVVRatio();
657}
658
660{
661 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
662 throw std::runtime_error("BrHtoZgaRatio called with a class whose parent is not NPbase");
663}
664
666{
667 return myNPbase->BrHZgaRatio();
668}
669
671{
672 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
673 throw std::runtime_error("BrHtoZgallRatio called with a class whose parent is not NPbase");
674}
675
677{
678 return myNPbase->BrHZgallRatio();
679}
680
682{
683 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
684 throw std::runtime_error("BrHtoZgaeeRatio called with a class whose parent is not NPbase");
685}
686
688{
689 return myNPbase->BrHZgaeeRatio();
690}
691
693{
694 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
695 throw std::runtime_error("BrHtoZgamumuRatio called with a class whose parent is not NPbase");
696}
697
699{
700 return myNPbase->BrHZgamumuRatio();
701}
702
704{
705 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
706 throw std::runtime_error("BrHtogagaRatio called with a class whose parent is not NPbase");
707}
708
710{
711 return myNPbase->BrHgagaRatio();
712}
713
715{
716 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
717 throw std::runtime_error("BrHtomumuRatio called with a class whose parent is not NPbase");
718}
719
721{
722 return myNPbase->BrHmumuRatio();
723}
724
726{
727 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
728 throw std::runtime_error("BrHtotautauRatio called with a class whose parent is not NPbase");
729}
730
732{
733 return myNPbase->BrHtautauRatio();
734}
735
737{
738 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
739 throw std::runtime_error("BrHtoccRatio called with a class whose parent is not NPbase");
740}
741
743{
744 return myNPbase->BrHccRatio();
745}
746
748{
749 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
750 throw std::runtime_error("BrHtobbRatio called with a class whose parent is not NPbase");
751}
752
754{
755 return myNPbase->BrHbbRatio();
756}
757
758// -----------------------------------------------------------------------------
759// More 4 fermion decays
760// -----------------------------------------------------------------------------
761
762
764: ThObservable(SM_i)
765{
766 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
767 throw std::runtime_error("BrHto2l2vRatio called with a class whose parent is not NPbase");
768}
769
771{
772 return myNPbase->BrH2l2vRatio();
773}
774
775
777: ThObservable(SM_i)
778{
779 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
780 throw std::runtime_error("BrHtoevmuvRatio called with a class whose parent is not NPbase");
781}
782
784{
785 return myNPbase->BrHevmuvRatio();
786}
787
788
790: ThObservable(SM_i)
791{
792 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
793 throw std::runtime_error("BrHto2e2vRatio called with a class whose parent is not NPbase");
794}
795
797{
798 // SM decay widths (from MG simulations)
799 double wH2e2vSM=0.93291e-06, wH2evSM=0.10152e-04;
800
801 // Sum
802 double wH2e2vTSM=wH2e2vSM+wH2evSM;
803
804 return ( (wH2e2vSM*(myNPbase->BrH2e2vRatio()) + wH2evSM*(myNPbase->BrH2evRatio())) / wH2e2vTSM );
805}
806
807
809: ThObservable(SM_i)
810{
811 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
812 throw std::runtime_error("BrHto2mu2vRatio called with a class whose parent is not NPbase");
813}
814
816{
817 // SM decay widths (from MG simulations)
818 double wH2mu2vSM=0.93288e-06, wH2muvSM=0.10163e-04;
819
820 // Sum
821 double wH2mu2vTSM=wH2mu2vSM+wH2muvSM;
822
823 return ( (wH2mu2vSM*(myNPbase->BrH2mu2vRatio()) + wH2muvSM*(myNPbase->BrH2muvRatio())) / wH2mu2vTSM );
824}
825
826
828: ThObservable(SM_i)
829{
830 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
831 throw std::runtime_error("BrHto4lRatio called with a class whose parent is not NPbase");
832}
833
835{
836 return myNPbase->BrH4lRatio();
837}
838
839
841: ThObservable(SM_i)
842{
843 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
844 throw std::runtime_error("BrHto4eRatio called with a class whose parent is not NPbase");
845}
846
848{
849 return myNPbase->BrH4eRatio();
850}
851
852
854: ThObservable(SM_i)
855{
856 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
857 throw std::runtime_error("BrHto4muRatio called with a class whose parent is not NPbase");
858}
859
861{
862 return myNPbase->BrH4muRatio();
863}
864
865
867: ThObservable(SM_i)
868{
869 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
870 throw std::runtime_error("BrHto2e2muRatio called with a class whose parent is not NPbase");
871}
872
874{
875 return myNPbase->BrH2e2muRatio();
876}
877
878
879
881: ThObservable(SM_i)
882{
883 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
884 throw std::runtime_error("BrHtolljjRatio called with a class whose parent is not NPbase");
885}
886
888{
889 return myNPbase->BrHlljjRatio();
890}
891
892
894: ThObservable(SM_i)
895{
896 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
897 throw std::runtime_error("BrHtolvjjRatio called with a class whose parent is not NPbase");
898}
899
901{
902 return myNPbase->BrHlvjjRatio();
903}
904
905
907: ThObservable(SM_i)
908{
909 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
910 throw std::runtime_error("BrHtolv_lvorjjRatio called with a class whose parent is not NPbase");
911}
912
914{
915 return myNPbase->BrHlv_lvorjjRatio();
916}
917
918
920: ThObservable(SM_i)
921{
922 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
923 throw std::runtime_error("BrHtoll_vvorjjRatio called with a class whose parent is not NPbase");
924}
925
927{
928 return myNPbase->BrHll_vvorjjRatio();
929}
930
931// -----------------------------------------------------------------------------
932// Ratios of BR (ratios with SM)
933// -----------------------------------------------------------------------------
934
936{
937 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
938 throw std::runtime_error("BrHtogaga_over_mumu_Ratio called with a class whose parent is not NPbase");
939}
940
942{
943 if ((this->getModel()).isModelLinearized()) {
944 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrHmumuRatio()));
945 } else {
946 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrHmumuRatio());
947 }
948}
949
951{
952 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
953 throw std::runtime_error("BrHtoZga_over_mumu_Ratio called with a class whose parent is not NPbase");
954}
955
957{
958 if ((this->getModel()).isModelLinearized()) {
959 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrHmumuRatio()));
960 } else {
961 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrHmumuRatio());
962 }
963}
964
966{
967 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
968 throw std::runtime_error("BrHtoZmumuga_over_mumu_Ratio called with a class whose parent is not NPbase");
969}
970
972{
973 if ((this->getModel()).isModelLinearized()) {
974 return (1.0 + (myNPbase->BrHZgamumuRatio()) - (myNPbase->BrHmumuRatio()));
975 } else {
977 }
978}
979
981{
982 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
983 throw std::runtime_error("BrHtoZga_over_4mu_Ratio called with a class whose parent is not NPbase");
984}
985
987{
988 if ((this->getModel()).isModelLinearized()) {
989 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrH4muRatio()));
990 } else {
991 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrH4muRatio());
992 }
993}
994
996{
997 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
998 throw std::runtime_error("BrHtoZmumuga_over_4mu_Ratio called with a class whose parent is not NPbase");
999}
1000
1002{
1003 if ((this->getModel()).isModelLinearized()) {
1004 return (1.0 + (myNPbase->BrHZgamumuRatio()) - (myNPbase->BrH4muRatio()));
1005 } else {
1006 return (myNPbase->BrHZgamumuRatio()) / (myNPbase->BrH4muRatio());
1007 }
1008}
1009
1011{
1012 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1013 throw std::runtime_error("BrHtogaga_over_4l_Ratio called with a class whose parent is not NPbase");
1014}
1015
1017{
1018 if ((this->getModel()).isModelLinearized()) {
1019 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrH4lRatio()));
1020 } else {
1021 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrH4lRatio());
1022 }
1023}
1024
1026{
1027 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1028 throw std::runtime_error("BrHtobb_over_4l_Ratio called with a class whose parent is not NPbase");
1029}
1030
1032{
1033 if ((this->getModel()).isModelLinearized()) {
1034 return (1.0 + (myNPbase->BrHbbRatio()) - (myNPbase->BrH4lRatio()));
1035 } else {
1036 return (myNPbase->BrHbbRatio()) / (myNPbase->BrH4lRatio());
1037 }
1038}
1039
1040
1042{
1043 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1044 throw std::runtime_error("BrHto2l2v_over_4l_Ratio called with a class whose parent is not NPbase");
1045}
1046
1048{
1049 if ((this->getModel()).isModelLinearized()) {
1050 return (1.0 + (myNPbase->BrH2l2vRatio()) - (myNPbase->BrH4lRatio()));
1051 } else {
1052 return (myNPbase->BrH2l2vRatio()) / (myNPbase->BrH4lRatio());
1053 }
1054}
1055
1056
1058{
1059 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1060 throw std::runtime_error("BrHtotautau_over_4l_Ratio called with a class whose parent is not NPbase");
1061}
1062
1064{
1065 if ((this->getModel()).isModelLinearized()) {
1066 return (1.0 + (myNPbase->BrHtautauRatio()) - (myNPbase->BrH4lRatio()));
1067 } else {
1068 return (myNPbase->BrHtautauRatio()) / (myNPbase->BrH4lRatio());
1069 }
1070}
1071
1072
1074{
1075 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1076 throw std::runtime_error("BrHtogaga_over_2e2mu_Ratio called with a class whose parent is not NPbase");
1077}
1078
1080{
1081 if ((this->getModel()).isModelLinearized()) {
1082 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrH2e2muRatio()));
1083 } else {
1084 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrH2e2muRatio());
1085 }
1086}
1087
1089{
1090 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1091 throw std::runtime_error("BrHtoZga_over_4l_Ratio called with a class whose parent is not NPbase");
1092}
1093
1095{
1096 if ((this->getModel()).isModelLinearized()) {
1097 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrH4lRatio()));
1098 } else {
1099 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrH4lRatio());
1100 }
1101}
1102
1104{
1105 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1106 throw std::runtime_error("BrHtomumu_over_4l_Ratio called with a class whose parent is not NPbase");
1107}
1108
1110{
1111 if ((this->getModel()).isModelLinearized()) {
1112 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrH4lRatio()));
1113 } else {
1114 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrH4lRatio());
1115 }
1116}
1117
1119{
1120 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1121 throw std::runtime_error("BrHtomumu_over_4mu_Ratio called with a class whose parent is not NPbase");
1122}
1123
1125{
1126 if ((this->getModel()).isModelLinearized()) {
1127 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrH4muRatio()));
1128 } else {
1129 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrH4muRatio());
1130 }
1131}
1132
1134{
1135 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1136 throw std::runtime_error("BrHto4l_over_gaga_Ratio called with a class whose parent is not NPbase");
1137}
1138
1140{
1141 if ((this->getModel()).isModelLinearized()) {
1142 return (1.0 + (myNPbase->BrH4lRatio()) - (myNPbase->BrHgagaRatio()));
1143 } else {
1144 return (myNPbase->BrH4lRatio()) / (myNPbase->BrHgagaRatio());
1145 }
1146}
1147
1149{
1150 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1151 throw std::runtime_error("BrHtoZga_over_gaga_Ratio called with a class whose parent is not NPbase");
1152}
1153
1155{
1156 if ((this->getModel()).isModelLinearized()) {
1157 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrHgagaRatio()));
1158 } else {
1159 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrHgagaRatio());
1160 }
1161}
1162
1164{
1165 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1166 throw std::runtime_error("BrHtomumu_over_gaga_Ratio called with a class whose parent is not NPbase");
1167}
1168
1170{
1171 if ((this->getModel()).isModelLinearized()) {
1172 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrHgagaRatio()));
1173 } else {
1174 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrHgagaRatio());
1175 }
1176}
1177
1178
1180{
1181 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1182 throw std::runtime_error("BrHto2l2v_over_gaga_Ratio called with a class whose parent is not NPbase");
1183}
1184
1186{
1187 if ((this->getModel()).isModelLinearized()) {
1188 return (1.0 + (myNPbase->BrH2l2vRatio()) - (myNPbase->BrHgagaRatio()));
1189 } else {
1190 return (myNPbase->BrH2l2vRatio()) / (myNPbase->BrHgagaRatio());
1191 }
1192}
1193
1194
1196{
1197 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1198 throw std::runtime_error("BrHtobb_over_cc_Ratio called with a class whose parent is not NPbase");
1199}
1200
1202{
1203 if ((this->getModel()).isModelLinearized()) {
1204 return (1.0 + (myNPbase->BrHbbRatio()) - (myNPbase->BrHccRatio()));
1205 } else {
1206 return (myNPbase->BrHbbRatio()) / (myNPbase->BrHccRatio());
1207 }
1208}
1209
1210
1212{
1213 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1214 throw std::runtime_error("BrHtogaga_over_gg_Ratio called with a class whose parent is not NPbase");
1215}
1216
1218{
1219 if ((this->getModel()).isModelLinearized()) {
1220 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrHggRatio()));
1221 } else {
1222 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrHggRatio());
1223 }
1224}
1225
1226
1228{
1229 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1230 throw std::runtime_error("BrHtogg_over_bb_Ratio called with a class whose parent is not NPbase");
1231}
1232
1234{
1235 if ((this->getModel()).isModelLinearized()) {
1236 return (1.0 + (myNPbase->BrHggRatio()) - (myNPbase->BrHbbRatio()));
1237 } else {
1238 return (myNPbase->BrHggRatio()) / (myNPbase->BrHbbRatio());
1239 }
1240}
1241
1242
1244{
1245 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1246 throw std::runtime_error("BrHtogg_over_cc_Ratio called with a class whose parent is not NPbase");
1247}
1248
1250{
1251 if ((this->getModel()).isModelLinearized()) {
1252 return (1.0 + (myNPbase->BrHggRatio()) - (myNPbase->BrHccRatio()));
1253 } else {
1254 return (myNPbase->BrHggRatio()) / (myNPbase->BrHccRatio());
1255 }
1256}
1257
1258
1259// -----------------------------------------------------------------------------
1260// Full signal strengths (prod x decay)
1261// -----------------------------------------------------------------------------
1262
1263muggHgaga::muggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1264: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1265{
1266 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1267 throw std::runtime_error("muggHgaga called with a class whose parent is not NPbase");
1268}
1269
1271{
1272 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1273 //AG: Most general expression including quadratic corrections.
1274 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1275 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1276 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1277 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1278 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1279 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1280
1281 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1282 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1283 double Br1 = dGammaR1-dGammaRTot1;
1284 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1285 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1286 } else {
1287 return myNPbase->muggHgaga(sqrt_s);
1288 }
1289}
1290
1291muggHgagaInt::muggHgagaInt(const StandardModel& SM_i, const double sqrt_s_i)
1292: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1293{
1294 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1295 throw std::runtime_error("muggHgagaInt called with a class whose parent is not NPbase");
1296}
1297
1299{
1301}
1302
1303muVBFHgaga::muVBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1304: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1305{
1306 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1307 throw std::runtime_error("muVBFHgaga called with a class whose parent is not NPbase");
1308}
1309
1311{
1312 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1313 //AG: Most general expression including quadratic corrections.
1314 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1315 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1316 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1317 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1318 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1319 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1320
1321 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1322 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1323 double Br1 = dGammaR1-dGammaRTot1;
1324 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1325
1326 double mu;
1327
1328 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1329
1330 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1331
1332 return mu;
1333 } else {
1334 return myNPbase->muVBFHgaga(sqrt_s);
1335 }
1336}
1337
1338muZHgaga::muZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1339: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1340{
1341 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1342 throw std::runtime_error("muZHgaga called with a class whose parent is not NPbase");
1343}
1344
1346{
1347 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1348 //AG: Most general expression including quadratic corrections.
1349 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1350 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1351 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
1352 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
1353 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1354 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1355
1356 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1357 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1358 double Br1 = dGammaR1-dGammaRTot1;
1359 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1360
1361 double mu;
1362
1363 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1364
1365 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1366
1367 return mu;
1368
1369 } else {
1370 return myNPbase->muZHgaga(sqrt_s);
1371 }
1372}
1373
1374muWHgaga::muWHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1375: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1376{
1377 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1378 throw std::runtime_error("muWHgaga called with a class whose parent is not NPbase");
1379}
1380
1382{
1383 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1384 //AG: Most general expression including quadratic corrections.
1385 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1386 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1387 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
1388 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
1389 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1390 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1391
1392 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1393 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1394 double Br1 = dGammaR1-dGammaRTot1;
1395 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1396
1397 double mu;
1398
1399 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1400
1401 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1402
1403 return mu;
1404
1405 } else {
1406 return myNPbase->muWHgaga(sqrt_s);
1407 }
1408}
1409
1410muVHgaga::muVHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1411: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1412{
1413 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1414 throw std::runtime_error("muVHgaga called with a class whose parent is not NPbase");
1415}
1416
1418{
1419 if ((this->getModel()).isModelLinearized()) {
1420 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1421 } else {
1422 return myNPbase->muVHgaga(sqrt_s);
1423 }
1424}
1425
1426muttHgaga::muttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1427: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1428{
1429 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1430 throw std::runtime_error("muttHgaga called with a class whose parent is not NPbase");
1431}
1432
1434{
1435 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1436 //AG: Most general expression including quadratic corrections.
1437 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1438 //return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1439 double muProd1 = myNPbase->delta_muttH_1(sqrt_s);
1440 double muProd2 = myNPbase->delta_muttH_2(sqrt_s);
1441 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1442 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1443
1444 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1445 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1446 double Br1 = dGammaR1-dGammaRTot1;
1447 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1448
1449 double mu;
1450
1451 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1452
1453 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1454
1455 return mu;
1456
1457 } else {
1458 return myNPbase->muttHgaga(sqrt_s);
1459 }
1460}
1461
1462mutHgaga::mutHgaga(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1463: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1464{
1465 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1466 throw std::runtime_error("mutHgaga called with a class whose parent is not NPbase");
1467}
1468
1470{
1471 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1472 //AG: Most general expression including quadratic corrections.
1473 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1474 double muProd1 = myNPbase->delta_mutH_1(sqrt_s);
1475 double muProd2 = myNPbase->delta_mutH_2(sqrt_s);
1476 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1477 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1478
1479 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1480 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1481 double Br1 = dGammaR1-dGammaRTot1;
1482 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1483
1484 double mu;
1485
1486 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1487
1488 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1489
1490 return mu;
1491
1492 } else {
1493 //VM: Just in case someone wants to add directly the production*decay
1494 //(which is the observable we fit at the end)
1495 double NPmutHgaga = myNPbase->mutHgaga(sqrt_s);
1496 if(NPmutHgaga==1.0){
1497 return ((myNPbase->mutH(sqrt_s)) )*(myNPbase->BrHgagaRatio());
1498 } else{
1499 return NPmutHgaga;
1500 }
1501 }
1502}
1503
1504muggHpbbH_Hgaga::muggHpbbH_Hgaga(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1505: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1506{
1507 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1508 throw std::runtime_error("muggHpbbH_Hgaga called with a class whose parent is not NPbase");
1509}
1510
1512{
1513 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1514 //AG: Most general expression including quadratic corrections.
1515 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1516 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1517 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1518 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1519 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1520
1521 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1522 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1523 double Br1 = dGammaR1-dGammaRTot1;
1524 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1525
1526 double mu;
1527
1528 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1529
1530 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1531
1532 return mu;
1533
1534 } else {
1535 //VM: Just in case someone wants to add directly the production*decay
1536 //(which is the observable we fit at the end)
1537 //Also, the bbH is missing here, I'll leave it as it was for the
1538 //moment (since bbH is really suppressed).
1539 double NPmuggHpbbH_Hgaga = myNPbase->muggHpbbH_Hgaga(sqrt_s);
1540 if (NPmuggHpbbH_Hgaga == 1.0){
1541 return (myNPbase->muggHgaga(sqrt_s));
1542 } else{
1543 return NPmuggHpbbH_Hgaga;
1544 }
1545 }
1546}
1547
1548muttHptH_Hgaga::muttHptH_Hgaga(const StandardModel& SM_i, const double sqrt_s_i)//AG:added
1549: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1550{
1551 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1552 throw std::runtime_error("muttHptH_Hgaga called with a class whose parent is not NPbase");
1553}
1554
1556{
1557 //VM:Note that these values are valid for 13 TeV, they are not general
1558 //We should access the SM function that has all the values (for the
1559 //different energies). The values are slightly different, we should
1560 //check this.
1561 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1562 double xsSM_ttH = 0.499873;
1563 double xsSM_tH = 0.0821;
1564 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
1565 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
1566
1567 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1568 //AG: Most general expression including quadratic corrections.
1569 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1570 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1571 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1572 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1573 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1574
1575 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1576 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1577 double Br1 = dGammaR1-dGammaRTot1;
1578 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1579
1580 double mu;
1581
1582 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1583
1584 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1585
1586 return mu;
1587
1588 } else {
1589 //VM: Just in case someone wants to add directly the production*decay
1590 //(which is the observable we fit at the end)
1591 double NPmuttHptH_Hgaga = myNPbase->muttHptH_Hgaga(sqrt_s);
1592 if(NPmuttHptH_Hgaga==1.0){
1593 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHgagaRatio()) ;
1594 } else {
1595 return NPmuttHptH_Hgaga;
1596 }
1597 }
1598}
1599
1600muggHZga::muggHZga(const StandardModel& SM_i, const double sqrt_s_i)
1601: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1602{
1603 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1604 throw std::runtime_error("muggHZga called with a class whose parent is not NPbase");
1605}
1606
1608{
1609 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1610 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1611 //AG: Most general expression including quadratic corrections.
1612 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1613 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1614 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1615 double dGammaR1 = myNPbase->deltaGammaHZgaRatio1();
1616 double dGammaR2 = myNPbase->deltaGammaHZgaRatio2();
1617
1618 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1619 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1620 double Br1 = dGammaR1-dGammaRTot1;
1621 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1622
1623 double mu;
1624
1625 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1626
1627 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1628
1629 return mu;
1630
1631 } else {
1632 return myNPbase->muggHZga(sqrt_s);
1633 }
1634}
1635
1636muggHZgamumu::muggHZgamumu(const StandardModel& SM_i, const double sqrt_s_i)
1637: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1638{
1639 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1640 throw std::runtime_error("muggHZgamumu called with a class whose parent is not NPbase");
1641}
1642
1644{
1645 if ((this->getModel()).isModelLinearized()) {
1646 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZgamumuRatio()));
1647 } else {
1649 }
1650}
1651
1652muVBFHZga::muVBFHZga(const StandardModel& SM_i, const double sqrt_s_i)
1653: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1654{
1655 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1656 throw std::runtime_error("muVBFHZga called with a class whose parent is not NPbase");
1657}
1658
1660{
1661 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1662 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1663 //AG: Most general expression including quadratic corrections.
1664 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1665 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1666 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1667 double dGammaR1 = myNPbase->deltaGammaHZgaRatio1();
1668 double dGammaR2 = myNPbase->deltaGammaHZgaRatio2();
1669
1670 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1671 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1672 double Br1 = dGammaR1-dGammaRTot1;
1673 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1674
1675 double mu;
1676
1677 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1678
1679 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1680
1681 return mu;
1682
1683 } else {
1684 return myNPbase->muVBFHZga(sqrt_s);
1685 }
1686}
1687
1688muZHZga::muZHZga(const StandardModel& SM_i, const double sqrt_s_i)
1689: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1690{
1691 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1692 throw std::runtime_error("muZHZga called with a class whose parent is not NPbase");
1693}
1694
1696{
1697 if ((this->getModel()).isModelLinearized()) {
1698 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1699 } else {
1700 return myNPbase->muZHZga(sqrt_s);
1701 }
1702}
1703
1704muWHZga::muWHZga(const StandardModel& SM_i, const double sqrt_s_i)
1705: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1706{
1707 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1708 throw std::runtime_error("muWHZga called with a class whose parent is not NPbase");
1709}
1710
1712{
1713 if ((this->getModel()).isModelLinearized()) {
1714 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1715 } else {
1716 return myNPbase->muWHZga(sqrt_s);
1717 }
1718}
1719
1720muVHZga::muVHZga(const StandardModel& SM_i, const double sqrt_s_i)
1721: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1722{
1723 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1724 throw std::runtime_error("muVHZga called with a class whose parent is not NPbase");
1725}
1726
1728{
1729 if ((this->getModel()).isModelLinearized()) {
1730 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1731 } else {
1732 return myNPbase->muVHZga(sqrt_s);
1733 }
1734}
1735
1736muttHZga::muttHZga(const StandardModel& SM_i, const double sqrt_s_i)
1737: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1738{
1739 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1740 throw std::runtime_error("muttHZga called with a class whose parent is not NPbase");
1741}
1742
1744{
1745 if ((this->getModel()).isModelLinearized()) {
1746 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1747 } else {
1748 return myNPbase->muttHZga(sqrt_s);
1749 }
1750}
1751
1752muggHZZ::muggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1753: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1754{
1755 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1756 throw std::runtime_error("muggHZZ called with a class whose parent is not NPbase");
1757}
1758
1760{
1761 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1762 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1763 //AG: Most general expression including quadratic corrections.
1764 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1765 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1766 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1767 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1768 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1769
1770 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1771 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1772 double Br1 = dGammaR1-dGammaRTot1;
1773 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1774
1775 double mu;
1776
1777 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1778
1779 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1780
1781 return mu;
1782
1783 } else {
1784 return myNPbase->muggHZZ(sqrt_s);
1785 }
1786}
1787
1788muVBFHZZ::muVBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1789: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1790{
1791 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1792 throw std::runtime_error("muVBFHZZ called with a class whose parent is not NPbase");
1793}
1794
1796{
1797 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1798 //AG: Most general expression including quadratic corrections.
1799 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1800 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHZZRatio()));
1801 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1802 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1803 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1804 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1805
1806 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1807 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1808 double Br1 = dGammaR1-dGammaRTot1;
1809 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1810
1811 double mu;
1812
1813 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1814
1815 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1816
1817 return mu;
1818
1819 } else {
1820 return myNPbase->muVBFHZZ(sqrt_s);
1821 }
1822}
1823
1824muZHZZ::muZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1825: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1826{
1827 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1828 throw std::runtime_error("muZHZZ called with a class whose parent is not NPbase");
1829}
1830
1832{
1833 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1834 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1835 //AG: Most general expression including quadratic corrections.
1836 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1837 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
1838 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
1839 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1840 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1841
1842 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1843 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1844 double Br1 = dGammaR1-dGammaRTot1;
1845 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1846
1847 double mu;
1848
1849 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1850
1851 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1852
1853 return mu;
1854
1855 } else {
1856 return myNPbase->muZHZZ(sqrt_s);
1857 }
1858}
1859
1860muWHZZ::muWHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1861: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1862{
1863 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1864 throw std::runtime_error("muWHZZ called with a class whose parent is not NPbase");
1865}
1866
1868{
1869 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1870 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1871 //AG: Most general expression including quadratic corrections.
1872 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1873 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
1874 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
1875 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1876 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1877
1878 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1879 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1880 double Br1 = dGammaR1-dGammaRTot1;
1881 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1882
1883 double mu;
1884
1885 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1886
1887 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1888
1889 return mu;
1890
1891 } else {
1892 return myNPbase->muWHZZ(sqrt_s);
1893 }
1894}
1895
1896muVHZZ::muVHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1897: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1898{
1899 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1900 throw std::runtime_error("muVHZZ called with a class whose parent is not NPbase");
1901}
1902
1904{
1905 //VM:Note that these values are valid for 13 TeV, they are not general
1906 //We should access the SM function that has all the values (for the
1907 //different energies). The values are slightly different, we should
1908 //check this.
1909 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1910 double xsSM_WH = 1.21539;
1911 double xsSM_ZH = 0.795910;
1912 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
1913 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
1914 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1915 //AG: Most general expression including quadratic corrections.
1916 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1917 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1918 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
1919 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
1920 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1921 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1922
1923 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1924 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1925 double Br1 = dGammaR1-dGammaRTot1;
1926 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1927
1928 double mu;
1929
1930 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1931
1932 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1933
1934 return mu;
1935
1936 } else {
1937 //return myNPbase->muVHZZ(sqrt_s);
1938 //VM: Just in case someone wants to add directly the production*decay
1939 //(which is the observable we fit at the end)
1940 double NPmuVHZZ = myNPbase->muVHZZ(sqrt_s);
1941 if(NPmuVHZZ==1.0){
1942 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHZZRatio());
1943 } else {
1944 return NPmuVHZZ;
1945 }
1946 }
1947}
1948
1949muttHZZ::muttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1950: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1951{
1952 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1953 throw std::runtime_error("muttHZZ called with a class whose parent is not NPbase");
1954}
1955
1957{
1958 if ((this->getModel()).isModelLinearized()) {
1959 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1960 } else {
1961 return myNPbase->muttHZZ(sqrt_s);
1962 }
1963}
1964
1965muttHptH_HZZ::muttHptH_HZZ(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1966: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1967{
1968 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1969 throw std::runtime_error("muttHptH_HZZ called with a class whose parent is not NPbase");
1970}
1971
1973{
1974 //VM:Note that these values are valid for 13 TeV, they are not general
1975 //We should access the SM function that has all the values (for the
1976 //different energies). The values are slightly different, we should
1977 //check this.
1978 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1979 double xsSM_ttH = 0.499873;
1980 double xsSM_tH = 0.0821;
1981 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
1982 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
1983 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1984 //AG: Most general expression including quadratic corrections.
1985 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1986 //return ( 1.0 + muProd1 + (myNPbase->BrHZZRatio()-1.) );
1987 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1988 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1989 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1990 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1991
1992 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1993 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1994 double Br1 = dGammaR1-dGammaRTot1;
1995 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1996
1997 double mu;
1998
1999 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2000
2001 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2002
2003 return mu;
2004
2005 } else {
2006
2007 //VM: Just in case someone wants to add directly the production*decay
2008 //(which is the observable we fit at the end)
2009 double NPmuttHptH_HZZ = myNPbase->muttHptH_HZZ(sqrt_s);
2010 if(NPmuttHptH_HZZ==1.0){
2011 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHZZRatio()) ;
2012 } else {
2013 return NPmuttHptH_HZZ;
2014 }
2015 }
2016}
2017
2018muttHptH_Hmumu::muttHptH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i)//AG:added
2019: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2020{
2021 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2022 throw std::runtime_error("muttHptH_Hmumu called with a class whose parent is not NPbase");
2023}
2024
2026{
2027 //VM:Note that these values are valid for 13 TeV, they are not general
2028 //We should access the SM function that has all the values (for the
2029 //different energies). The values are slightly different, we should
2030 //check this.
2031 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2032 double xsSM_ttH = 0.499873;
2033 double xsSM_tH = 0.0821;
2034 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2035 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
2036 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2037 //return ( 1.0
2038 // + ( xsSM_ttH*(myNPbase->muttH(sqrt_s)-1.) + xsSM_tH*(myNPbase->mutH(sqrt_s)-1.) )/(xsSM_ttH+xsSM_tH)
2039 // + (myNPbase->BrHmumuRatio()-1.));
2040 double muProd1 = ( xsSM_ttH*(myNPbase->muttH(sqrt_s)-1.) + xsSM_tH*(myNPbase->mutH(sqrt_s)-1.) )/(xsSM_ttH+xsSM_tH);
2041 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2042 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2043 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2044
2045 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2046 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2047 double Br1 = dGammaR1-dGammaRTot1;
2048 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2049
2050 double mu;
2051
2052 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2053
2054 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2055
2056 return mu;
2057
2058 } else {
2059
2060 //VM: Just in case someone wants to add directly the production*decay
2061 //(which is the observable we fit at the end)
2062 double NPmuttHptH_Hmumu = myNPbase->muttHptH_Hmumu(sqrt_s);
2063 if(NPmuttHptH_Hmumu==1.0){
2064 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHmumuRatio());
2065 } else {
2066 return NPmuttHptH_Hmumu;
2067 }
2068 }
2069}
2070
2071muggHpbbH_HZZ::muggHpbbH_HZZ(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2072: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2073{
2074 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2075 throw std::runtime_error("muggHpbbH_HZZ called with a class whose parent is not NPbase");
2076}
2077
2079{
2080 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2081 //AG: Most general expression including quadratic corrections.
2082 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2083 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.));
2084 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2085 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2086 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
2087 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
2088
2089 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2090 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2091 double Br1 = dGammaR1-dGammaRTot1;
2092 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2093
2094 double mu;
2095
2096 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2097
2098 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2099
2100 return mu;
2101
2102 } else {
2103 //VM: Just in case someone wants to add directly the production*decay
2104 //(which is the observable we fit at the end)
2105 //Also, the bbH is missing here, I'll leave it as it was for the
2106 //moment (since bbH is really suppressed in the SM).
2107 double NPmuggHpbbH_HZZ = myNPbase->muggHpbbH_HZZ(sqrt_s);
2108 if (NPmuggHpbbH_HZZ == 1.0){
2109 return (myNPbase->muggHZZ(sqrt_s));
2110 } else{
2111 return NPmuggHpbbH_HZZ;
2112 }
2113 }
2114}
2115
2116muggHZZ4l::muggHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2117: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2118{
2119 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2120 throw std::runtime_error("muggHZZ4l called with a class whose parent is not NPbase");
2121}
2122
2124{
2125 if ((this->getModel()).isModelLinearized()) {
2126 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2127 } else {
2128 return myNPbase->muggHZZ4l(sqrt_s);
2129 }
2130}
2131
2132muggHZZ4mu::muggHZZ4mu(const StandardModel& SM_i, const double sqrt_s_i)
2133: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2134{
2135 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2136 throw std::runtime_error("muggHZZ4mu called with a class whose parent is not NPbase");
2137}
2138
2140{
2141 if ((this->getModel()).isModelLinearized()) {
2142 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH4muRatio()));
2143 } else {
2144 return (myNPbase->muggH(sqrt_s))*(myNPbase->BrH4muRatio());
2145 }
2146}
2147
2148muVBFHZZ4l::muVBFHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2149: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2150{
2151 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2152 throw std::runtime_error("muVBFHZZ4l called with a class whose parent is not NPbase");
2153}
2154
2156{
2157 if ((this->getModel()).isModelLinearized()) {
2158 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrH4lRatio()));
2159 } else {
2160 return myNPbase->muVBFHZZ4l(sqrt_s);
2161 }
2162}
2163
2164muZHZZ4l::muZHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2165: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2166{
2167 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2168 throw std::runtime_error("muZHZZ4l called with a class whose parent is not NPbase");
2169}
2170
2172{
2173 if ((this->getModel()).isModelLinearized()) {
2174 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2175 } else {
2176 return myNPbase->muZHZZ4l(sqrt_s);
2177 }
2178}
2179
2180muWHZZ4l::muWHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2181: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2182{
2183 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2184 throw std::runtime_error("muWHZZ4l called with a class whose parent is not NPbase");
2185}
2186
2188{
2189 if ((this->getModel()).isModelLinearized()) {
2190 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2191 } else {
2192 return myNPbase->muWHZZ4l(sqrt_s);
2193 }
2194}
2195
2196muVHZZ4l::muVHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2197: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2198{
2199 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2200 throw std::runtime_error("muVHZZ4l called with a class whose parent is not NPbase");
2201}
2202
2204{
2205 if ((this->getModel()).isModelLinearized()) {
2206 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2207 } else {
2208 return myNPbase->muVHZZ4l(sqrt_s);
2209 }
2210}
2211
2212muttHZZ4l::muttHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2213: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2214{
2215 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2216 throw std::runtime_error("muttHZZ4l called with a class whose parent is not NPbase");
2217}
2218
2220{
2221 if ((this->getModel()).isModelLinearized()) {
2222 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2223 } else {
2224 return myNPbase->muttHZZ4l(sqrt_s);
2225 }
2226}
2227
2228muggHWW::muggHWW(const StandardModel& SM_i, const double sqrt_s_i)
2229: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2230{
2231 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2232 throw std::runtime_error("muggHWW called with a class whose parent is not NPbase");
2233}
2234
2236{
2237 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2238 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2239 //AG: Most general expression including quadratic corrections.
2240 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2241 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2242 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2243 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2244 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2245
2246 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2247 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2248 double Br1 = dGammaR1-dGammaRTot1;
2249 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2250
2251 double mu;
2252
2253 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2254
2255 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2256
2257 return mu;
2258
2259 } else {
2260 return myNPbase->muggHWW(sqrt_s);
2261 }
2262}
2263
2264muVBFHWW::muVBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
2265: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2266{
2267 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2268 throw std::runtime_error("muVBFHWW called with a class whose parent is not NPbase");
2269}
2270
2272{
2273 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2274 //AG: Most general expression including quadratic corrections.
2275 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2276 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHWWRatio()));
2277 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2278 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2279 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2280 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2281
2282 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2283 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2284 double Br1 = dGammaR1-dGammaRTot1;
2285 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2286
2287 double mu;
2288
2289 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2290
2291 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2292
2293 return mu;
2294
2295 } else {
2296 return myNPbase->muVBFHWW(sqrt_s);
2297 }
2298}
2299
2300muZHWW::muZHWW(const StandardModel& SM_i, const double sqrt_s_i)
2301: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2302{
2303 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2304 throw std::runtime_error("muZHWW called with a class whose parent is not NPbase");
2305}
2306
2308{
2309 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2310 //AG: Most general expression including quadratic corrections.
2311 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2312 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2313 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
2314 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
2315 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2316 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2317
2318 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2319 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2320 double Br1 = dGammaR1-dGammaRTot1;
2321 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2322
2323 double mu;
2324
2325 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2326
2327 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2328
2329 return mu;
2330
2331 } else {
2332 return myNPbase->muZHWW(sqrt_s);
2333 }
2334}
2335
2336muWHWW::muWHWW(const StandardModel& SM_i, const double sqrt_s_i)
2337: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2338{
2339 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2340 throw std::runtime_error("muWHWW called with a class whose parent is not NPbase");
2341}
2342
2344{
2345 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2346 //AG: Most general expression including quadratic corrections.
2347 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2348 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2349 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
2350 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
2351 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2352 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2353
2354 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2355 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2356 double Br1 = dGammaR1-dGammaRTot1;
2357 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2358
2359 double mu;
2360
2361 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2362
2363 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2364
2365 return mu;
2366
2367 } else {
2368 return myNPbase->muWHWW(sqrt_s);
2369 }
2370}
2371
2372muVHWW::muVHWW(const StandardModel& SM_i, const double sqrt_s_i)
2373: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2374{
2375 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2376 throw std::runtime_error("muVHWW called with a class whose parent is not NPbase");
2377}
2378
2380{
2381 if ((this->getModel()).isModelLinearized()) {
2382 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2383 } else {
2384 return myNPbase->muVHWW(sqrt_s);
2385 }
2386}
2387
2388muttHWW::muttHWW(const StandardModel& SM_i, const double sqrt_s_i)
2389: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2390{
2391 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2392 throw std::runtime_error("muttHWW called with a class whose parent is not NPbase");
2393}
2394
2396{
2397 if ((this->getModel()).isModelLinearized()) {
2398 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2399 } else {
2400 return myNPbase->muttHWW(sqrt_s);
2401 }
2402}
2403
2404muttHptH_HWW::muttHptH_HWW(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2405: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2406{
2407 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2408 throw std::runtime_error("muttHptH_HWW called with a class whose parent is not NPbase");
2409}
2410
2412{
2413
2414 //VM:Note that these values are valid for 13 TeV, they are not general
2415 //We should access the SM function that has all the values (for the
2416 //different energies). The values are slightly different, we should
2417 //check this.
2418 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2419 double xsSM_ttH = 0.499873;
2420 double xsSM_tH = 0.0821;
2421 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2422 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
2423 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2424 //AG: Most general expression including quadratic corrections.
2425 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2426 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2427 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2428 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2429 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2430
2431 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2432 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2433 double Br1 = dGammaR1-dGammaRTot1;
2434 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2435
2436 double mu;
2437
2438 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2439
2440 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2441
2442 return mu;
2443
2444 } else {
2445
2446 //VM: Just in case someone wants to add directly the production*decay
2447 //(which is the observable we fit at the end)
2448 double NPmuttHptH_HWW = myNPbase->muttHptH_HWW(sqrt_s);
2449 if(NPmuttHptH_HWW==1.0){
2450 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHWWRatio()) ;
2451 } else {
2452 return NPmuttHptH_HWW;
2453 }
2454 }
2455}
2456
2457muggHpbbH_HWW::muggHpbbH_HWW(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2458: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2459{
2460 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2461 throw std::runtime_error("muggHpbbH_HWW called with a class whose parent is not NPbase");
2462}
2463
2465{
2466 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2467 //AG: Most general expression including quadratic corrections.
2468 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2469 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.));
2470 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2471 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2472 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2473 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2474
2475 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2476 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2477 double Br1 = dGammaR1-dGammaRTot1;
2478 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2479
2480 double mu;
2481
2482 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2483
2484 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2485
2486 return mu;
2487
2488 } else {
2489
2490 //VM: Just in case someone wants to add directly the production*decay
2491 //(which is the observable we fit at the end)
2492 //Also, the bbH is missing here, I'll leave it as it was for the
2493 //moment (since bbH is really suppressed in the SM).
2494 double NPmuggHpbbH_HWW = myNPbase->muggHpbbH_HWW(sqrt_s);
2495 if (NPmuggHpbbH_HWW == 1.0){
2496 return (myNPbase->muggHWW(sqrt_s));
2497 } else{
2498 return NPmuggHpbbH_HWW;
2499 }
2500 }
2501}
2502
2503muggHWW2l2v::muggHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2504: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2505{
2506 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2507 throw std::runtime_error("muggHWW2l2v called with a class whose parent is not NPbase");
2508}
2509
2511{
2512 if ((this->getModel()).isModelLinearized()) {
2513 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2514 } else {
2515 return myNPbase->muggHWW2l2v(sqrt_s);
2516 }
2517}
2518
2519muVBFHWW2l2v::muVBFHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2520: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2521{
2522 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2523 throw std::runtime_error("muVBFHWW2l2v called with a class whose parent is not NPbase");
2524}
2525
2527{
2528 if ((this->getModel()).isModelLinearized()) {
2529 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2530 } else {
2531 return myNPbase->muVBFHWW2l2v(sqrt_s);
2532 }
2533}
2534
2535muZHWW2l2v::muZHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2536: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2537{
2538 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2539 throw std::runtime_error("muZHWW2l2v called with a class whose parent is not NPbase");
2540}
2541
2543{
2544 if ((this->getModel()).isModelLinearized()) {
2545 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2546 } else {
2547 return myNPbase->muZHWW2l2v(sqrt_s);
2548 }
2549}
2550
2551muWHWW2l2v::muWHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2552: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2553{
2554 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2555 throw std::runtime_error("muWHWW2l2v called with a class whose parent is not NPbase");
2556}
2557
2559{
2560 if ((this->getModel()).isModelLinearized()) {
2561 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2562 } else {
2563 return myNPbase->muWHWW2l2v(sqrt_s);
2564 }
2565}
2566
2567muVHWW2l2v::muVHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2568: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2569{
2570 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2571 throw std::runtime_error("muVHWW2l2v called with a class whose parent is not NPbase");
2572}
2573
2575{
2576 if ((this->getModel()).isModelLinearized()) {
2577 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2578 } else {
2579 return myNPbase->muVHWW2l2v(sqrt_s);
2580 }
2581}
2582
2583muttHWW2l2v::muttHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2584: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2585{
2586 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2587 throw std::runtime_error("muttHWW2l2v called with a class whose parent is not NPbase");
2588}
2589
2591{
2592 if ((this->getModel()).isModelLinearized()) {
2593 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2594 } else {
2595 return myNPbase->muttHWW2l2v(sqrt_s);
2596 }
2597}
2598
2599muttHVV::muttHVV(const StandardModel& SM_i, const double sqrt_s_i)
2600: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2601{
2602 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2603 throw std::runtime_error("muttHVV called with a class whose parent is not NPbase");
2604}
2605
2607{
2608 if ((this->getModel()).isModelLinearized()) {
2609 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHVVRatio()));
2610 } else {
2611 return (myNPbase->muttH(sqrt_s)) * (myNPbase->BrHVVRatio());
2612 }
2613}
2614
2615muggHmumu::muggHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2616: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2617{
2618 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2619 throw std::runtime_error("muggHmumu called with a class whose parent is not NPbase");
2620}
2621
2623{
2624 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2625 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2626 //AG: Most general expression including quadratic corrections.
2627 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2628 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2629 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2630 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2631 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2632
2633 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2634 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2635 double Br1 = dGammaR1-dGammaRTot1;
2636 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2637
2638 double mu;
2639
2640 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2641
2642 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2643
2644 return mu;
2645
2646 } else {
2647 return myNPbase->muggHmumu(sqrt_s);
2648 }
2649}
2650
2651muVBFHmumu::muVBFHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2652: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2653{
2654 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2655 throw std::runtime_error("muVBFHmumu called with a class whose parent is not NPbase");
2656}
2657
2659{
2660 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2661 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2662 //AG: Most general expression including quadratic corrections.
2663 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2664 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2665 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2666 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2667 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2668
2669 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2670 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2671 double Br1 = dGammaR1-dGammaRTot1;
2672 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2673
2674 double mu;
2675
2676 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2677
2678 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2679
2680 return mu;
2681
2682 } else {
2683 return myNPbase->muVBFHmumu(sqrt_s);
2684 }
2685}
2686
2687muZHmumu::muZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2688: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2689{
2690 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2691 throw std::runtime_error("muZHmumu called with a class whose parent is not NPbase");
2692}
2693
2695{
2696 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2697 //AG: Most general expression including quadratic corrections.
2698 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2699 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
2700 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
2701 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2702 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2703
2704 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2705 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2706 double Br1 = dGammaR1-dGammaRTot1;
2707 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2708
2709 double mu;
2710
2711 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2712
2713 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2714
2715 return mu;
2716
2717 } else {
2718 return myNPbase->muZHmumu(sqrt_s);
2719 }
2720}
2721
2722muWHmumu::muWHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2723: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2724{
2725 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2726 throw std::runtime_error("muWHmumu called with a class whose parent is not NPbase");
2727}
2728
2730{
2731 if ((this->getModel()).isModelLinearized()) {
2732 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2733 } else {
2734 return myNPbase->muWHmumu(sqrt_s);
2735 }
2736}
2737
2738muVHmumu::muVHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2739: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2740{
2741 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2742 throw std::runtime_error("muVHmumu called with a class whose parent is not NPbase");
2743}
2744
2746{
2747
2748 //VM:Note that these values are valid for 13 TeV, they are not general
2749 //We should access the SM function that has all the values (for the
2750 //different energies). The values are slightly different, we should
2751 //check this.
2752 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2753 double xsSM_WH = 1.21539;
2754 double xsSM_ZH = 0.795910;
2755 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
2756 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
2757 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2758 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2759 //AG: Most general expression including quadratic corrections.
2760 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2761 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2762 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2763 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2764 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2765
2766 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2767 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2768 double Br1 = dGammaR1-dGammaRTot1;
2769 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2770
2771 double mu;
2772
2773 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2774
2775 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2776
2777 return mu;
2778
2779 } else {
2780 //return myNPbase->muVHmumu(sqrt_s);
2781 //VM: Just in case someone wants to add directly the production*decay
2782 //(which is the observable we fit at the end)
2783 double NPmuVHmumu = myNPbase->muVHmumu(sqrt_s);
2784 if(NPmuVHmumu==1.0){
2785 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHmumuRatio());
2786 } else {
2787 return NPmuVHmumu;
2788 }
2789
2790 }
2791}
2792
2793muttHmumu::muttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2794: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2795{
2796 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2797 throw std::runtime_error("muttHmumu called with a class whose parent is not NPbase");
2798}
2799
2801{
2802 if ((this->getModel()).isModelLinearized()) {
2803 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2804 } else {
2805 return myNPbase->muttHmumu(sqrt_s);
2806 }
2807}
2808
2809muggHpttHptHpbbH_Hmumu::muggHpttHptHpbbH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2810: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2811{
2812 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2813 throw std::runtime_error("muggHpttHptHpbbH_Hmumu called with a class whose parent is not NPbase");
2814}
2815
2817{
2818 //VM:Note that these values are valid for 13 TeV, they are not general
2819 //We should access the SM function that has all the values (for the
2820 //different energies). The values are slightly different, we should
2821 //check this. Furthermore, the bbH is not included. In the SM this is
2822 //very suppressed (and it's probably also the case in the SMEFT) but
2823 //in some NP models it may not be the case.Unfortunately, bbH is not
2824 //obtained in the SMEFT, we could just set delta_mubbH to zero in the
2825 //SMEFT and add here the general expression.
2826 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2827 double xsSM_ggHbbH = 44.745;
2828 double xsSM_ttH = 0.4998;
2829 double xsSM_tH = 0.084769;
2830 //double xsSM_ggH = myNPbase->computeSigmaggH(sqrt_s);
2831 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2832 //double xsSM_tH = myNPbase->computeSigmatH(sqrt_s);
2833 //double xsSM_bbH = myNPbase->computeSigmabbH(sqrt_s);
2834
2835
2836
2837 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2838 //AG: Most general expression including quadratic corrections.
2839 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2840 double muProd1 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_1(sqrt_s)) + xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ggHbbH+xsSM_ttH+xsSM_tH) ;
2841 double muProd2 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_2(sqrt_s)) + xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ggHbbH+xsSM_ttH+xsSM_tH) ;
2842 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2843 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2844
2845 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2846 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2847 double Br1 = dGammaR1-dGammaRTot1;
2848 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2849
2850 double mu;
2851
2852 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2853
2854 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2855
2856 return mu;
2857
2858 } else {
2859
2860 //VM: Just in case someone wants to add directly the production*decay
2861 //(which is the observable we fit at the end). Furthermore, the Hbb
2862 //is not added in the original formula, fine for the SM (probably also
2863 //for the SMEFT) but not for all NP models.
2864 double NPmuggHpttHptHpbbH_Hmumu = myNPbase->muggHpttHptHpbbH_Hmumu(sqrt_s);
2865 if(NPmuggHpttHptHpbbH_Hmumu==1.0){
2866 return ( (xsSM_ggHbbH*(myNPbase->muggH(sqrt_s))+xsSM_ttH*(myNPbase->muttH(sqrt_s))+xsSM_tH*(myNPbase->mutH(sqrt_s))) / (xsSM_ggHbbH+xsSM_ttH+xsSM_tH) )*(myNPbase->BrHmumuRatio()) ;
2867 } else {
2868 return NPmuggHpttHptHpbbH_Hmumu;
2869 }
2870 }
2871}
2872
2873muVBFpVH_Hmumu::muVBFpVH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2874: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2875{
2876 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2877 throw std::runtime_error("muVBFpVH_Hmumu called with a class whose parent is not NPbase");
2878}
2879
2881{
2882
2883 //VM:Note that these values are valid for 13 TeV, they are not general
2884 //We should access the SM function that has all the values (for the
2885 //different energies). The values are slightly different, we should
2886 //check this.
2887 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2888 double xsSM_VBF = 3.49948;
2889 double xsSM_WH = 1.21539;
2890 double xsSM_ZH = 0.795910;
2891 //double xsSM_VBF = myNPbase->computeSigmaVBF(sqrt_s);
2892 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
2893 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
2894 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2895 //AG: Most general expression including quadratic corrections.
2896 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2897 double muProd1 = ( xsSM_VBF*(myNPbase->delta_muVBF_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) + xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) )/(xsSM_VBF+xsSM_WH+xsSM_ZH);
2898 double muProd2 = ( xsSM_VBF*(myNPbase->delta_muVBF_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) + xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) )/(xsSM_VBF+xsSM_WH+xsSM_ZH);
2899 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2900 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2901
2902 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2903 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2904 double Br1 = dGammaR1-dGammaRTot1;
2905 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2906
2907 double mu;
2908
2909 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2910
2911 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2912
2913 return mu;
2914
2915 } else {
2916
2917 //VM: Just in case someone wants to add directly the production*decay
2918 //(which is the observable we fit at the end).
2919 double NPmuVBFpVH_Hmumu = myNPbase->muVBFpVH_Hmumu(sqrt_s);
2920 if(NPmuVBFpVH_Hmumu==1.0){
2921 return ( (xsSM_VBF*(myNPbase->muVBF(sqrt_s))+xsSM_WH*(myNPbase->muWH(sqrt_s))+xsSM_ZH*(myNPbase->muZH(sqrt_s))) / (xsSM_VBF+xsSM_WH+xsSM_ZH) )*(myNPbase->BrHmumuRatio()) ;
2922 } else {
2923 return NPmuVBFpVH_Hmumu;
2924 }
2925 }
2926}
2927
2928muggHtautau::muggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2929: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2930{
2931 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2932 throw std::runtime_error("muggHtautau called with a class whose parent is not NPbase");
2933}
2934
2936{
2937 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2938 //AG: Most general expression including quadratic corrections.
2939 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2940 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2941 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2942 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2943 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2944 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2945
2946 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2947 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2948 double Br1 = dGammaR1-dGammaRTot1;
2949 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2950
2951 double mu;
2952
2953 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2954
2955 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2956
2957 return mu;
2958
2959 } else {
2960 return myNPbase->muggHtautau(sqrt_s);
2961 }
2962}
2963
2964muVBFHtautau::muVBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2965: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2966{
2967 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2968 throw std::runtime_error("muVBFHtautau called with a class whose parent is not NPbase");
2969}
2970
2972{
2973 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2974 //AG: Most general expression including quadratic corrections.
2975 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2976 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2977 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2978 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2979 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2980 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2981
2982 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2983 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2984 double Br1 = dGammaR1-dGammaRTot1;
2985 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2986
2987 double mu;
2988
2989 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2990
2991 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2992
2993 return mu;
2994
2995 } else {
2996 return myNPbase->muVBFHtautau(sqrt_s);
2997 }
2998}
2999
3000
3001
3002muVBFpVHtautau::muVBFpVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3003: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3004{
3005 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3006 throw std::runtime_error("muVBFpVHtautau called with a class whose parent is not NPbase");
3007}
3008
3010{
3011 if ((this->getModel()).isModelLinearized()) {
3012 return ( -1.0 + (myNPbase->muVBFpVH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3013 } else {
3015 }
3016}
3017
3018
3019muZHtautau::muZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3020: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3021{
3022 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3023 throw std::runtime_error("muZHtautau called with a class whose parent is not NPbase");
3024}
3025
3026double muZHtautau::computeThValue() //AG:modified
3027{
3028 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3029 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3030 //AG: Most general expression including quadratic corrections.
3031 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3032 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3033 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
3034 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
3035 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3036 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3037
3038 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3039 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3040 double Br1 = dGammaR1-dGammaRTot1;
3041 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3042
3043 double mu;
3044
3045 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3046
3047 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3048
3049 return mu;
3050
3051 } else {
3052 return myNPbase->muZHtautau(sqrt_s);
3053 }
3054}
3055
3056muWHtautau::muWHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3057: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3058{
3059 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3060 throw std::runtime_error("muWHtautau called with a class whose parent is not NPbase");
3061}
3062
3064{
3065 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3066 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3067 //AG: Most general expression including quadratic corrections.
3068 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3069 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
3070 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
3071 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3072 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3073
3074 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3075 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3076 double Br1 = dGammaR1-dGammaRTot1;
3077 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3078
3079 /*std::cout << "muProd1="<<muProd1<<std::endl;
3080 std::cout << "muProd2="<<muProd2<<std::endl;
3081 std::cout << "dGammaR1="<<dGammaR1<<std::endl;
3082 std::cout << "dGammaR2="<<dGammaR2<<std::endl;
3083 std::cout << "dGammaRTot1="<<dGammaRTot1<<std::endl;
3084 std::cout << "dGammaRTot2="<<dGammaRTot2<<std::endl;
3085
3086 std::cout<<myNPbase->muWH(sqrt_s)<<std::endl;
3087 std::cout<<myNPbase->muWH(sqrt_s)<<std::endl;*/
3088
3089 double mu;
3090
3091 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3092
3093 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3094
3095 return mu;
3096
3097 } else {
3098 return myNPbase->muWHtautau(sqrt_s);
3099 }
3100}
3101
3102muVHtautau::muVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3103: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3104{
3105 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3106 throw std::runtime_error("muVHtautau called with a class whose parent is not NPbase");
3107}
3108
3110{
3111 //VM:Note that these values are valid for 13 TeV, they are not general
3112 //We should access the SM function that has all the values (for the
3113 //different energies). The values are slightly different, we should
3114 //check this.
3115 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3116 double xsSM_WH = 1.21539;
3117 double xsSM_ZH = 0.795910;
3118 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
3119 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
3120 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3121 //AG: Most general expression including quadratic corrections.
3122 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3123 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3124 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
3125 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
3126 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3127 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3128
3129 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3130 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3131 double Br1 = dGammaR1-dGammaRTot1;
3132 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3133
3134 double mu;
3135
3136 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3137
3138 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3139
3140 return mu;
3141
3142 } else {
3143 //return myNPbase->muVHtautau(sqrt_s);
3144
3145 //VM: Just in case someone wants to add directly the production*decay
3146 //(which is the observable we fit at the end)
3147 double NPmuVHtautau = myNPbase->muVHtautau(sqrt_s);
3148 if(NPmuVHtautau==1.0){
3149 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHtautauRatio());
3150 } else {
3151 return NPmuVHtautau;
3152 }
3153 }
3154}
3155
3156muttHtautau::muttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3157: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3158{
3159 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3160 throw std::runtime_error("muttHtautau called with a class whose parent is not NPbase");
3161}
3162
3164{
3165 if ((this->getModel()).isModelLinearized()) {
3166 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3167 } else {
3168 return myNPbase->muttHtautau(sqrt_s);
3169 }
3170}
3171
3172muttHptH_Htautau::muttHptH_Htautau(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3173: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3174{
3175 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3176 throw std::runtime_error("muttHptH_Htautau called with a class whose parent is not NPbase");
3177}
3178
3180{
3181 //VM:Note that these values are valid for 13 TeV, they are not general
3182 //We should access the SM function that has all the values (for the
3183 //different energies). The values are slightly different, we should
3184 //check this.
3185 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3186 double xsSM_ttH = 0.499873;
3187 double xsSM_tH = 0.0821;
3188 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
3189 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
3190 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3191 //AG: Most general expression including quadratic corrections.
3192 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3193 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3194 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3195 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3196 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3197
3198 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3199 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3200 double Br1 = dGammaR1-dGammaRTot1;
3201 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3202
3203 double mu;
3204
3205 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3206
3207 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3208
3209 return mu;
3210
3211 } else {
3212
3213 //VM: Just in case someone wants to add directly the production*decay
3214 //(which is the observable we fit at the end)
3215 double NPmuttHptH_Htautau = myNPbase->muttHptH_Htautau(sqrt_s);
3216 if(NPmuttHptH_Htautau==1.0){
3217 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHtautauRatio()) ;
3218 } else {
3219 return NPmuttHptH_Htautau;
3220 }
3221
3222 }
3223}
3224
3225muggHpbbH_Htautau::muggHpbbH_Htautau(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3226: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3227{
3228 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3229 throw std::runtime_error("muggHpbbH_Htautau called with a class whose parent is not NPbase");
3230}
3231
3233{
3234 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3235 //AG: Most general expression including quadratic corrections.
3236 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3237 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.));
3238 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
3239 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
3240 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3241 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3242
3243 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3244 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3245 double Br1 = dGammaR1-dGammaRTot1;
3246 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3247
3248 double mu;
3249
3250 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3251
3252 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3253
3254 return mu;
3255
3256 } else {
3257
3258 //VM: Just in case someone wants to add directly the production*decay
3259 //(which is the observable we fit at the end)
3260 //Also, the bbH is missing here, I'll leave it as it was for the
3261 //moment (since bbH is really suppressed in the SM).
3262 double NPmuggHpbbH_Htautau = myNPbase->muggHpbbH_Htautau(sqrt_s);
3263 if (NPmuggHpbbH_Htautau == 1.0){
3264 return (myNPbase->muggHtautau(sqrt_s));
3265 } else{
3266 return NPmuggHpbbH_Htautau;
3267 }
3268 }
3269}
3270
3271muggHbb::muggHbb(const StandardModel& SM_i, const double sqrt_s_i)
3272: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3273{
3274 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3275 throw std::runtime_error("muggHbb called with a class whose parent is not NPbase");
3276}
3277
3279{
3280 if ((this->getModel()).isModelLinearized()) {
3281 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3282 //AG: Most general expression including quadratic corrections.
3283 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3284 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
3285 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
3286 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3287 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3288
3289 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3290 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3291 double Br1 = dGammaR1-dGammaRTot1;
3292 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3293
3294 double mu;
3295
3296 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3297
3298 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3299
3300 return mu;
3301
3302 } else {
3303 return myNPbase->muggHbb(sqrt_s);
3304 }
3305}
3306
3307muVBFHbb::muVBFHbb(const StandardModel& SM_i, const double sqrt_s_i)
3308: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3309{
3310 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3311 throw std::runtime_error("muVBFHbb called with a class whose parent is not NPbase");
3312}
3313
3315{
3316 if ((this->getModel()).isModelLinearized()) {
3317 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHbbRatio()));
3318 } else {
3319 return myNPbase->muVBFHbb(sqrt_s);
3320 }
3321}
3322
3323muZHbb::muZHbb(const StandardModel& SM_i, const double sqrt_s_i)
3324: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3325{
3326 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3327 throw std::runtime_error("muZHbb called with a class whose parent is not NPbase");
3328}
3329
3331{
3332 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3333 //AG: Most general expression including quadratic corrections.
3334 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3335 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3336 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
3337 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
3338 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3339 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3340
3341 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3342 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3343 double Br1 = dGammaR1-dGammaRTot1;
3344 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3345
3346 double mu;
3347
3348 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3349
3350 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3351
3352 return mu;
3353
3354 } else {
3355 return myNPbase->muZHbb(sqrt_s);
3356 }
3357}
3358
3359muWHbb::muWHbb(const StandardModel& SM_i, const double sqrt_s_i)
3360: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3361{
3362 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3363 throw std::runtime_error("muWHbb called with a class whose parent is not NPbase");
3364}
3365
3367{
3368 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3369 //AG: Most general expression including quadratic corrections.
3370 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3371 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3372 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
3373 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
3374 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3375 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3376
3377 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3378 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3379 double Br1 = dGammaR1-dGammaRTot1;
3380 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3381
3382 double mu;
3383
3384 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3385
3386 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3387
3388 return mu;
3389
3390 } else {
3391 return myNPbase->muWHbb(sqrt_s);
3392 }
3393}
3394
3395muVHbb::muVHbb(const StandardModel& SM_i, const double sqrt_s_i)
3396: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3397{
3398 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3399 throw std::runtime_error("muVHbb called with a class whose parent is not NPbase");
3400}
3401
3403{
3404 if ((this->getModel()).isModelLinearized()) {
3405 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3406 } else {
3407 return myNPbase->muVHbb(sqrt_s);
3408 }
3409}
3410
3411muttHbb::muttHbb(const StandardModel& SM_i, const double sqrt_s_i)
3412: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3413{
3414 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3415 throw std::runtime_error("muttHbb called with a class whose parent is not NPbase");
3416}
3417
3419{
3420 if ((this->getModel()).isModelLinearized()) {
3421 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3422 } else {
3423 return myNPbase->muttHbb(sqrt_s);
3424 }
3425}
3426
3427muttHptH_Hbb::muttHptH_Hbb(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3428: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3429{
3430 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3431 throw std::runtime_error("muttHptH_Hbb called with a class whose parent is not NPbase");
3432}
3433
3435{
3436 //VM:Note that these values are valid for 13 TeV, they are not general
3437 //We should access the SM function that has all the values (for the
3438 //different energies). The values are slightly different, we should
3439 //check this.
3440 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3441 double xsSM_ttH = 0.499873;
3442 double xsSM_tH = 0.0821;
3443 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
3444 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
3445 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3446 //AG: Most general expression including quadratic corrections.
3447 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3448 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3449 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3450 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3451 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3452
3453 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3454 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3455 double Br1 = dGammaR1-dGammaRTot1;
3456 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3457
3458 double mu;
3459
3460 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3461
3462 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3463
3464 return mu;
3465
3466 } else {
3467
3468
3469 //VM: Just in case someone wants to add directly the production*decay
3470 //(which is the observable we fit at the end)
3471 double NPmuttHptH_Hbb = myNPbase->muttHptH_Hbb(sqrt_s);
3472 if(NPmuttHptH_Hbb==1.0){
3473 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHbbRatio()) ;
3474 } else {
3475 return NPmuttHptH_Hbb;
3476 }
3477 }
3478}
3479
3480muggHpVBFpbbH_Hbb::muggHpVBFpbbH_Hbb(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3481: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3482{
3483 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3484 throw std::runtime_error("muggHpVBFpbbH_Hbb called with a class whose parent is not NPbase");
3485}
3486
3488{
3489 //VM:Note that these values are valid for 13 TeV, they are not general
3490 //We should access the SM function that has all the values (for the
3491 //different energies). The values are slightly different, we should
3492 //check this. Furthermore, the bbH is not included. In the SM this is
3493 //very suppressed (and it's probably also the case in the SMEFT) but
3494 //in some NP models it may not be the case.Unfortunately, bbH is not
3495 //obtained in the SMEFT, we could just set delta_mubbH to zero in the
3496 //SMEFT and add here the general expression.
3497 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3498 double xsSM_ggHbbH = 44.745;
3499 double xsSM_VBF = 3.49948;
3500 //double xsSM_ggH = myNPbase->computeSigmaggH(sqrt_s);
3501 //double xsSM_VBF = myNPbase->computeSigmaVBF(sqrt_s);
3502 //double xsSM_bbH = myNPbase->computeSigmabbH(sqrt_s);
3503 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3504 //AG: Most general expression including quadratic corrections.
3505 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3506 double muProd1 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_1(sqrt_s)) + xsSM_VBF*(myNPbase->delta_muVBF_1(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF);
3507 double muProd2 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_2(sqrt_s)) + xsSM_VBF*(myNPbase->delta_muVBF_2(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF);
3508 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3509 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3510
3511 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3512 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3513 double Br1 = dGammaR1-dGammaRTot1;
3514 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3515
3516 double mu;
3517
3518 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3519
3520 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3521
3522 return mu;
3523
3524 } else {
3525
3526
3527 //VM: Just in case someone wants to add directly the production*decay
3528 //(which is the observable we fit at the end). Furthermore, the Hbb
3529 //is not added in the original formula, fine for the SM (probably also
3530 //for the SMEFT) but not for all NP models.
3531 double NPmuggHpVBFpbbH_Hbb = myNPbase->muggHpVBFpbbH_Hbb(sqrt_s);
3532 if(NPmuggHpVBFpbbH_Hbb==1.0){
3533 return ( xsSM_ggHbbH*(myNPbase->muggH(sqrt_s)) + xsSM_VBF*(myNPbase->muVBF(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF) * (myNPbase->BrHbbRatio()) ;
3534 } else {
3535 return NPmuggHpVBFpbbH_Hbb;
3536 }
3537 }
3538}
3539
3540
3541
3542muVHcc::muVHcc(const StandardModel& SM_i, const double sqrt_s_i)
3543: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3544{
3545 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3546 throw std::runtime_error("muVHbb called with a class whose parent is not NPbase");
3547}
3548
3550{
3551 if ((this->getModel()).isModelLinearized()) {
3552 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHccRatio()));
3553 } else {
3554 return myNPbase->muVHcc(sqrt_s);
3555 }
3556}
3557
3558
3559muVBFBRinv::muVBFBRinv(const StandardModel& SM_i, const double sqrt_s_i)
3560: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3561{
3562 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3563 throw std::runtime_error("muVBFBRinv called with a class whose parent is not NPbase");
3564}
3565
3567{
3568
3569 return (myNPbase->muVBF(sqrt_s))*(myNPbase->Br_H_inv());
3570
3571}
3572
3573muVBFHinv::muVBFHinv(const StandardModel& SM_i, const double sqrt_s_i)
3574: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3575{
3576 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3577 throw std::runtime_error("muVBFHinv called with a class whose parent is not NPbase");
3578}
3579
3581{
3582
3583 if ((this->getModel()).isModelLinearized()) {
3584 return ((myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtoinvRatio()) - 1.0);
3585 } else {
3586 return (myNPbase->muVBF(sqrt_s))*(myNPbase->BrHtoinvRatio());
3587 }
3588
3589}
3590
3591
3592muVHBRinv::muVHBRinv(const StandardModel& SM_i, const double sqrt_s_i)
3593: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3594{
3595 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3596 throw std::runtime_error("muVHBRinv called with a class whose parent is not NPbase");
3597}
3598
3600{
3601
3602 return (myNPbase->muVH(sqrt_s))*(myNPbase->Br_H_inv());
3603
3604}
3605
3606muVHinv::muVHinv(const StandardModel& SM_i, const double sqrt_s_i)
3607: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3608{
3609 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3610 throw std::runtime_error("muVHinv called with a class whose parent is not NPbase");
3611}
3612
3614{
3615
3616 if ((this->getModel()).isModelLinearized()) {
3617 return ((myNPbase->muVH(sqrt_s)) + (myNPbase->BrHtoinvRatio()) - 1.0);
3618 } else {
3619 return (myNPbase->muVH(sqrt_s))*(myNPbase->BrHtoinvRatio());
3620 }
3621
3622}
3623
3624
3625muppHmumu::muppHmumu(const StandardModel& SM_i, const double sqrt_s_i)
3626: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3627{
3628 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3629 throw std::runtime_error("muppHmumu called with a class whose parent is not NPbase");
3630}
3631
3633{
3634 return myNPbase->muppHmumu(sqrt_s);
3635}
3636
3637muppHZga::muppHZga(const StandardModel& SM_i, const double sqrt_s_i)
3638: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3639{
3640 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3641 throw std::runtime_error("muppHZga called with a class whose parent is not NPbase");
3642}
3643
3645{
3646 return myNPbase->muppHZga(sqrt_s);
3647}
3648
3649muggHH2ga2b::muggHH2ga2b(const StandardModel& SM_i, const double sqrt_s_i)
3650: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3651{
3652 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3653 throw std::runtime_error("muggH called with a class whose parent is not NPbase");
3654}
3655
3657{
3658 if ((this->getModel()).isModelLinearized()) {
3659 return (-2.0 + (myNPbase->muggHH(sqrt_s)) + (myNPbase->BrHgagaRatio()) + (myNPbase->BrHbbRatio()));
3660 } else {
3662 }
3663}
3664
3665muttHZbbboost::muttHZbbboost(const StandardModel& SM_i, const double sqrt_s_i)
3666: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3667{
3668 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3669 throw std::runtime_error("muttHZbbboost called with a class whose parent is not NPbase");
3670}
3671
3673{
3674 return (myNPbase->muttHZbbboost(sqrt_s));
3675}
3676
3677//AG:begin
3678ggHgaga::ggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3679: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3680{
3681 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3682 throw std::runtime_error("ggHgaga called with a class whose parent is not NPbase");
3683}
3685{
3686 double SM_prediction = 0.0439; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3687 if ((this->getModel()).isModelLinearized()) {
3688 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3689 } else {
3690 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHgagaRatio());
3691 }
3692}
3693
3694
3695ggHZZ::ggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
3696: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3697{
3698 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3699 throw std::runtime_error("ggHZZ called with a class whose parent is not NPbase");
3700}
3702{
3703 double SM_prediction = 0.5197; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3704 if ((this->getModel()).isModelLinearized()) {
3705 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.) );
3706 } else {
3707 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHZZRatio());
3708 }
3709}
3710
3711
3712ggHWW::ggHWW(const StandardModel& SM_i, const double sqrt_s_i)
3713: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3714{
3715 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3716 throw std::runtime_error("ggHWW called with a class whose parent is not NPbase");
3717}
3719{
3720 double SM_prediction = 4.1603; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3721 if ((this->getModel()).isModelLinearized()) {
3722 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3723 } else {
3724 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHWWRatio());
3725 }
3726}
3727
3728
3729ggHtautau::ggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3730: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3731{
3732 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3733 throw std::runtime_error("ggHtautau called with a class whose parent is not NPbase");
3734}
3736{
3737 double SM_prediction = 1.2215; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3738 if ((this->getModel()).isModelLinearized()) {
3739 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3740 } else {
3741 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHtautauRatio());
3742 }
3743}
3744
3745
3746VBFHgaga::VBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3747: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3748{
3749 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3750 throw std::runtime_error("VBFHgaga called with a class whose parent is not NPbase");
3751}
3753{
3754 double SM_prediction = 0.0037; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3755 if ((this->getModel()).isModelLinearized()) {
3756 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3757 } else {
3758 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHgagaRatio());
3759 }
3760}
3761
3762
3763VBFHZZ::VBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
3764: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3765{
3766 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3767 throw std::runtime_error("VBFHZZ called with a class whose parent is not NPbase");
3768}
3770{
3771 double SM_prediction = 0.0530; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3772 if ((this->getModel()).isModelLinearized()) {
3773 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.) );
3774 } else {
3775 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHZZRatio());
3776 }
3777}
3778
3779
3780VBFHWW::VBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
3781: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3782{
3783 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3784 throw std::runtime_error("VBFHWW called with a class whose parent is not NPbase");
3785}
3787{
3788 double SM_prediction = 0.3494; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3789 if ((this->getModel()).isModelLinearized()) {
3790 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3791 } else {
3792 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHWWRatio());
3793 }
3794}
3795
3796
3797VBFHtautau::VBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3798: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3799{
3800 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3801 throw std::runtime_error("VBFHtautau called with a class whose parent is not NPbase");
3802}
3804{
3805 double SM_prediction = 0.1011; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3806 if ((this->getModel()).isModelLinearized()) {
3807 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3808 } else {
3809 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHtautauRatio());
3810 }
3811}
3812
3813
3814WHgaga::WHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3815: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3816{
3817 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3818 throw std::runtime_error("WHgaga called with a class whose parent is not NPbase");
3819}
3821{
3822 double SM_prediction = 0.0017; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3823 if ((this->getModel()).isModelLinearized()) {
3824 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3825 } else {
3826 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHgagaRatio());
3827 }
3828}
3829
3830
3831WHWW::WHWW(const StandardModel& SM_i, const double sqrt_s_i)
3832: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3833{
3834 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3835 throw std::runtime_error("WHWW called with a class whose parent is not NPbase");
3836}
3838{
3839 double SM_prediction = 0.1614; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3840 if ((this->getModel()).isModelLinearized()) {
3841 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3842 } else {
3843 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHWWRatio());
3844 }
3845}
3846
3847
3848WHtautau::WHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3849: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3850{
3851 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3852 throw std::runtime_error("WWHtautau called with a class whose parent is not NPbase");
3853}
3855{
3856 double SM_prediction = 0.0462; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3857 if ((this->getModel()).isModelLinearized()) {
3858 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3859 } else {
3860 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHtautauRatio());
3861 }
3862}
3863
3864
3865WHbb::WHbb(const StandardModel& SM_i, const double sqrt_s_i)
3866: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3867{
3868 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3869 throw std::runtime_error("WHbb called with a class whose parent is not NPbase");
3870}
3872{
3873 double SM_prediction = 0.4090; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3874 if ((this->getModel()).isModelLinearized()) {
3875 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
3876 } else {
3877 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHbbRatio());
3878 }
3879}
3880
3881
3882ZHgaga::ZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3883: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3884{
3885 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3886 throw std::runtime_error("ZHgaga called with a class whose parent is not NPbase");
3887}
3889{
3890 double SM_prediction = 0.0011; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3891 if ((this->getModel()).isModelLinearized()) {
3892 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3893 } else {
3894 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHgagaRatio());
3895 }
3896}
3897
3898
3899ZHWW::ZHWW(const StandardModel& SM_i, const double sqrt_s_i)
3900: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3901{
3902 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3903 throw std::runtime_error("ZHWW called with a class whose parent is not NPbase");
3904}
3906{
3907 double SM_prediction = 0.0996; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3908 if ((this->getModel()).isModelLinearized()) {
3909 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3910 } else {
3911 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHWWRatio());
3912 }
3913}
3914
3915
3916ZHtautau::ZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3917: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3918{
3919 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3920 throw std::runtime_error("ZHtautau called with a class whose parent is not NPbase");
3921}
3923{
3924 double SM_prediction = 0.0304; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3925 if ((this->getModel()).isModelLinearized()) {
3926 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3927 } else {
3928 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHtautauRatio());
3929 }
3930}
3931
3932
3933ZHbb::ZHbb(const StandardModel& SM_i, const double sqrt_s_i)
3934: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3935{
3936 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3937 throw std::runtime_error("ZHbb called with a class whose parent is not NPbase");
3938}
3940{
3941 double SM_prediction = 0.2410; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3942 if ((this->getModel()).isModelLinearized()) {
3943 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
3944 } else {
3945 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHbbRatio());
3946 }
3947}
3948
3949
3950ttHgaga::ttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3951: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3952{
3953 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3954 throw std::runtime_error("ttHgaga called with a class whose parent is not NPbase");
3955}
3957{
3958 double SM_prediction = 0.0004; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3959 if ((this->getModel()).isModelLinearized()) {
3960 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3961 } else {
3962 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHgagaRatio());
3963 }
3964}
3965
3966
3967ttHWW::ttHWW(const StandardModel& SM_i, const double sqrt_s_i)
3968: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3969{
3970 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3971 throw std::runtime_error("ttHWW called with a class whose parent is not NPbase");
3972}
3974{
3975 double SM_prediction = 0.0281; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3976 if ((this->getModel()).isModelLinearized()) {
3977 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3978 } else {
3979 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHWWRatio());
3980 }
3981}
3982
3983
3984ttHtautau::ttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3985: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3986{
3987 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3988 throw std::runtime_error("ttHtautau called with a class whose parent is not NPbase");
3989}
3991{
3992 double SM_prediction = 0.0106; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3993 if ((this->getModel()).isModelLinearized()) {
3994 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3995 } else {
3996 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHtautauRatio());
3997 }
3998}
3999
4000
4001ttHbb::ttHbb(const StandardModel& SM_i, const double sqrt_s_i)
4002: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4003{
4004 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4005 throw std::runtime_error("ttHbb called with a class whose parent is not NPbase");
4006}
4008{
4009 double SM_prediction = 0.0751; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
4010 if ((this->getModel()).isModelLinearized()) {
4011 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
4012 } else {
4013 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHbbRatio());
4014 }
4015}
4016
4017//AG:end
4018
4019UpperLimit_ppHZgammaA::UpperLimit_ppHZgammaA(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4020{
4021 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4022 throw std::runtime_error("UpperLimit_ppHZgammaA called with a class whose parent is not NPbase");
4023}
4024
4026{
4028}
4029
4030UpperLimit_ppHZgammaA13::UpperLimit_ppHZgammaA13(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4031{
4032 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4033 throw std::runtime_error("UpperLimit_ppHZgammaA13 called with a class whose parent is not NPbase");
4034}
4035
4037{
4039}
4040
4041UpperLimit_ppHZgammaC13::UpperLimit_ppHZgammaC13(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4042{
4043 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4044 throw std::runtime_error("UpperLimit_ppHZgammaC13 called with a class whose parent is not NPbase");
4045}
4046
4048{
4050}
4051
4052UpperLimit_ppHZgammaC::UpperLimit_ppHZgammaC(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4053{
4054 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4055 throw std::runtime_error("UpperLimit_ppHZgammaC called with a class whose parent is not NPbase");
4056}
4057
4059{
4061}
4062
4064{
4065 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4066 throw std::runtime_error("cg_plus_ct called with a class whose parent is not NPbase");
4067}
4068
4070{
4071 return myNPbase->cgplusct();
4072}
4073
4075{
4076 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4077 throw std::runtime_error("cga_plus_ct called with a class whose parent is not NPbase");
4078}
4079
4081{
4082 return myNPbase->cgaplusct();
4083}
4084
4086{
4087 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4088 throw std::runtime_error("cg_minus_cga called with a class whose parent is not NPbase");
4089}
4090
4092{
4093 return myNPbase->cgminuscga();
4094}
4095
4097{
4098 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4099 throw std::runtime_error("cV_plus_cb called with a class whose parent is not NPbase");
4100}
4101\
4102
4103
4105{
4106 return myNPbase->cVpluscb();
4107}
4108
4110{
4111 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4112 throw std::runtime_error("cV_plus_ctau called with a class whose parent is not NPbase");
4113}
4114
4116{
4117 return myNPbase->cVplusctau();
4118}
4119
4121{
4122 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4123 throw std::runtime_error("cb_minus_cc called with a class whose parent is not NPbase");
4124}
4125
4127{
4128 return myNPbase->cbminuscc();
4129}
4130
4132{
4133 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4134 throw std::runtime_error("cb_minus_ctau called with a class whose parent is not NPbase");
4135}
4136
4138{
4139 return myNPbase->cbminusctau();
4140}
4141
4143{
4144 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4145 throw std::runtime_error("cc_minus_ctau called with a class whose parent is not NPbase");
4146}
4147
4149{
4150 return myNPbase->ccminusctau();
4151}
4152
4153
4154// Full signal strengths at e+ e- colliders
4155// ----------------------------------------
4156
4157mueeZHbb::mueeZHbb(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4158: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4159{
4160 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4161 throw std::runtime_error("mueeZHbb called with a class whose parent is not NPbase");
4162}
4163
4165{
4166 if ((this->getModel()).isModelLinearized()) {
4167 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4168 } else {
4170 }
4171}
4172
4173mueeZHcc::mueeZHcc(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4174: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4175{
4176 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4177 throw std::runtime_error("mueeZHcc called with a class whose parent is not NPbase");
4178}
4179
4181{
4182 if ((this->getModel()).isModelLinearized()) {
4183 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHccRatio()) - 1.0);
4184 } else {
4186 }
4187}
4188
4189mueeZHss::mueeZHss(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4190: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4191{
4192 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4193 throw std::runtime_error("mueeZHss called with a class whose parent is not NPbase");
4194}
4195
4197{
4198 if ((this->getModel()).isModelLinearized()) {
4199 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHssRatio()) - 1.0);
4200 } else {
4202 }
4203}
4204
4205mueeZHgg::mueeZHgg(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4206: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4207{
4208 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4209 throw std::runtime_error("mueeZHgg called with a class whose parent is not NPbase");
4210}
4211
4213{
4214 if ((this->getModel()).isModelLinearized()) {
4215 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHggRatio()) - 1.0);
4216 } else {
4218 }
4219}
4220
4221mueeZHWW::mueeZHWW(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4222: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4223{
4224 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4225 throw std::runtime_error("mueeZHWW called with a class whose parent is not NPbase");
4226}
4227
4229{
4230 if ((this->getModel()).isModelLinearized()) {
4231 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHWWRatio()) - 1.0);
4232 } else {
4234 }
4235}
4236
4237mueeZHtautau::mueeZHtautau(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4238: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4239{
4240 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4241 throw std::runtime_error("mueeZHtautau called with a class whose parent is not NPbase");
4242}
4243
4245{
4246 if ((this->getModel()).isModelLinearized()) {
4247 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHtautauRatio()) - 1.0);
4248 } else {
4250 }
4251}
4252
4253mueeZHZZ::mueeZHZZ(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4254: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4255{
4256 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4257 throw std::runtime_error("mueeZHZZ called with a class whose parent is not NPbase");
4258}
4259
4261{
4262 if ((this->getModel()).isModelLinearized()) {
4263 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZZRatio()) - 1.0);
4264 } else {
4266 }
4267}
4268
4269mueeZHZga::mueeZHZga(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4270: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4271{
4272 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4273 throw std::runtime_error("mueeZHZga called with a class whose parent is not NPbase");
4274}
4275
4277{
4278 if ((this->getModel()).isModelLinearized()) {
4279 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZgaRatio()) - 1.0);
4280 } else {
4282 }
4283}
4284
4285mueeZHgaga::mueeZHgaga(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4286: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4287{
4288 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4289 throw std::runtime_error("mueeZHgaga called with a class whose parent is not NPbase");
4290}
4291
4293{
4294 if ((this->getModel()).isModelLinearized()) {
4295 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHgagaRatio()) - 1.0);
4296 } else {
4298 }
4299}
4300
4301mueeZHmumu::mueeZHmumu(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4302: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4303{
4304 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4305 throw std::runtime_error("mueeZHmumu called with a class whose parent is not NPbase");
4306}
4307
4309{
4310 if ((this->getModel()).isModelLinearized()) {
4311 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHmumuRatio()) - 1.0);
4312 } else {
4314 }
4315}
4316
4317mueeZHBRinv::mueeZHBRinv(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4318: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4319{
4320 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4321 throw std::runtime_error("mueeZHBRinv called with a class whose parent is not NPbase");
4322}
4323
4325{
4326
4328
4329}
4330
4331mueeZHinv::mueeZHinv(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4332: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4333{
4334 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4335 throw std::runtime_error("mueeZHinv called with a class whose parent is not NPbase");
4336}
4337
4339{
4340
4341 if ((this->getModel()).isModelLinearized()) {
4342 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHtoinvRatio()) - 1.0);
4343 } else {
4345 }
4346
4347}
4348
4349mueeWBFbb::mueeWBFbb(const StandardModel& SM_i, const double sqrt_s_i)
4350: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4351{
4352 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4353 throw std::runtime_error("mueeWBFbb called with a class whose parent is not NPbase");
4354
4355}
4356
4358{
4359 if ((this->getModel()).isModelLinearized()) {
4360 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4361 } else {
4362 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHbbRatio());
4363 }
4364}
4365
4366mueeWBFbbPol::mueeWBFbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4367: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4368{
4369 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4370 throw std::runtime_error("mueeWBFbbPol called with a class whose parent is not NPbase");
4371
4372}
4373
4375{
4376 if ((this->getModel()).isModelLinearized()) {
4377 return ((myNPbase->mueeWBFPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4378 } else {
4380 }
4381}
4382
4383mueeWBFcc::mueeWBFcc(const StandardModel& SM_i, const double sqrt_s_i)
4384: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4385{
4386 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4387 throw std::runtime_error("mueeWBFcc called with a class whose parent is not NPbase");
4388
4389}
4390
4392{
4393 if ((this->getModel()).isModelLinearized()) {
4394 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
4395 } else {
4396 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHccRatio());
4397 }
4398}
4399
4400mueeWBFgg::mueeWBFgg(const StandardModel& SM_i, const double sqrt_s_i)
4401: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4402{
4403 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4404 throw std::runtime_error("mueeWBFgg called with a class whose parent is not NPbase");
4405
4406}
4407
4409{
4410 if ((this->getModel()).isModelLinearized()) {
4411 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
4412 } else {
4413 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHggRatio());
4414 }
4415}
4416
4417mueeWBFWW::mueeWBFWW(const StandardModel& SM_i, const double sqrt_s_i)
4418: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4419{
4420 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4421 throw std::runtime_error("mueeWBFWW called with a class whose parent is not NPbase");
4422
4423}
4424
4426{
4427 if ((this->getModel()).isModelLinearized()) {
4428 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
4429 } else {
4430 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHWWRatio());
4431 }
4432}
4433
4434mueeWBFtautau::mueeWBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
4435: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4436{
4437 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4438 throw std::runtime_error("mueeWBFtautau called with a class whose parent is not NPbase");
4439
4440}
4441
4443{
4444 if ((this->getModel()).isModelLinearized()) {
4445 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
4446 } else {
4448 }
4449}
4450
4451mueeWBFZZ::mueeWBFZZ(const StandardModel& SM_i, const double sqrt_s_i)
4452: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4453{
4454 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4455 throw std::runtime_error("mueeWBFZZ called with a class whose parent is not NPbase");
4456
4457}
4458
4460{
4461 if ((this->getModel()).isModelLinearized()) {
4462 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
4463 } else {
4464 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHZZRatio());
4465 }
4466}
4467
4468mueeWBFZga::mueeWBFZga(const StandardModel& SM_i, const double sqrt_s_i)
4469: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4470{
4471 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4472 throw std::runtime_error("mueeWBFZga called with a class whose parent is not NPbase");
4473
4474}
4475
4477{
4478 if ((this->getModel()).isModelLinearized()) {
4479 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
4480 } else {
4481 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHZgaRatio());
4482 }
4483}
4484
4485mueeWBFgaga::mueeWBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
4486: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4487{
4488 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4489 throw std::runtime_error("mueeWBFgaga called with a class whose parent is not NPbase");
4490
4491}
4492
4494{
4495 if ((this->getModel()).isModelLinearized()) {
4496 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
4497 } else {
4499 }
4500}
4501
4502mueeWBFmumu::mueeWBFmumu(const StandardModel& SM_i, const double sqrt_s_i)
4503: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4504{
4505 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4506 throw std::runtime_error("mueeWBFmumu called with a class whose parent is not NPbase");
4507
4508}
4509
4511{
4512 if ((this->getModel()).isModelLinearized()) {
4513 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
4514 } else {
4516 }
4517}
4518
4519mueeHvvbb::mueeHvvbb(const StandardModel& SM_i, const double sqrt_s_i)
4520: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4521{
4522 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4523 throw std::runtime_error("mueeHvvbb called with a class whose parent is not NPbase");
4524
4525}
4526
4528{
4529 if ((this->getModel()).isModelLinearized()) {
4530 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4531 } else {
4532 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHbbRatio());
4533 }
4534}
4535
4536mueeHvvbbPol::mueeHvvbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4537: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4538{
4539 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4540 throw std::runtime_error("mueeHvvbbPol called with a class whose parent is not NPbase");
4541
4542}
4543
4545{
4546 if ((this->getModel()).isModelLinearized()) {
4547 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4548 } else {
4550 }
4551}
4552
4553mueeHvvcc::mueeHvvcc(const StandardModel& SM_i, const double sqrt_s_i)
4554: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4555{
4556 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4557 throw std::runtime_error("mueeHvvcc called with a class whose parent is not NPbase");
4558
4559}
4560
4562{
4563 if ((this->getModel()).isModelLinearized()) {
4564 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
4565 } else {
4566 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHccRatio());
4567 }
4568}
4569
4570mueeHvvccPol::mueeHvvccPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4571: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4572{
4573 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4574 throw std::runtime_error("mueeHvvccPol called with a class whose parent is not NPbase");
4575
4576}
4577
4579{
4580 if ((this->getModel()).isModelLinearized()) {
4581 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHccRatio()) - 1.0);
4582 } else {
4584 }
4585}
4586
4587
4588mueeHvvss::mueeHvvss(const StandardModel& SM_i, const double sqrt_s_i)
4589: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4590{
4591 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4592 throw std::runtime_error("mueeHvvss called with a class whose parent is not NPbase");
4593
4594}
4595
4597{
4598 if ((this->getModel()).isModelLinearized()) {
4599 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHssRatio()) - 1.0);
4600 } else {
4601 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHssRatio());
4602 }
4603}
4604
4605mueeHvvssPol::mueeHvvssPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4606: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4607{
4608 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4609 throw std::runtime_error("mueeHvvssPol called with a class whose parent is not NPbase");
4610
4611}
4612
4614{
4615 if ((this->getModel()).isModelLinearized()) {
4616 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHssRatio()) - 1.0);
4617 } else {
4619 }
4620}
4621
4622
4623mueeHvvgg::mueeHvvgg(const StandardModel& SM_i, const double sqrt_s_i)
4624: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4625{
4626 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4627 throw std::runtime_error("mueeHvvgg called with a class whose parent is not NPbase");
4628
4629}
4630
4632{
4633 if ((this->getModel()).isModelLinearized()) {
4634 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
4635 } else {
4636 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHggRatio());
4637 }
4638}
4639
4640mueeHvvggPol::mueeHvvggPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4641: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4642{
4643 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4644 throw std::runtime_error("mueeHvvggPol called with a class whose parent is not NPbase");
4645
4646}
4647
4649{
4650 if ((this->getModel()).isModelLinearized()) {
4651 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHggRatio()) - 1.0);
4652 } else {
4654 }
4655}
4656
4657mueeHvvWW::mueeHvvWW(const StandardModel& SM_i, const double sqrt_s_i)
4658: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4659{
4660 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4661 throw std::runtime_error("mueeHvvWW called with a class whose parent is not NPbase");
4662
4663}
4664
4666{
4667 if ((this->getModel()).isModelLinearized()) {
4668 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
4669 } else {
4670 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHWWRatio());
4671 }
4672}
4673
4674mueeHvvWWPol::mueeHvvWWPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4675: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4676{
4677 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4678 throw std::runtime_error("mueeHvvWWPol called with a class whose parent is not NPbase");
4679
4680}
4681
4683{
4684 if ((this->getModel()).isModelLinearized()) {
4685 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHWWRatio()) - 1.0);
4686 } else {
4688 }
4689}
4690
4691mueeHvvtautau::mueeHvvtautau(const StandardModel& SM_i, const double sqrt_s_i)
4692: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4693{
4694 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4695 throw std::runtime_error("mueeHvvtautau called with a class whose parent is not NPbase");
4696
4697}
4698
4700{
4701 if ((this->getModel()).isModelLinearized()) {
4702 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
4703 } else {
4705 }
4706}
4707
4708mueeHvvtautauPol::mueeHvvtautauPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4709: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4710{
4711 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4712 throw std::runtime_error("mueeHvvtautauPol called with a class whose parent is not NPbase");
4713
4714}
4715
4717{
4718 if ((this->getModel()).isModelLinearized()) {
4719 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHtautauRatio()) - 1.0);
4720 } else {
4722 }
4723}
4724
4725mueeHvvZZ::mueeHvvZZ(const StandardModel& SM_i, const double sqrt_s_i)
4726: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4727{
4728 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4729 throw std::runtime_error("mueeHvvZZ called with a class whose parent is not NPbase");
4730
4731}
4732
4734{
4735 if ((this->getModel()).isModelLinearized()) {
4736 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
4737 } else {
4738 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHZZRatio());
4739 }
4740}
4741
4742mueeHvvZZPol::mueeHvvZZPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4743: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4744{
4745 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4746 throw std::runtime_error("mueeHvvZZPol called with a class whose parent is not NPbase");
4747
4748}
4749
4751{
4752 if ((this->getModel()).isModelLinearized()) {
4753 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZZRatio()) - 1.0);
4754 } else {
4756 }
4757}
4758
4759mueeHvvZga::mueeHvvZga(const StandardModel& SM_i, const double sqrt_s_i)
4760: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4761{
4762 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4763 throw std::runtime_error("mueeHvvZga called with a class whose parent is not NPbase");
4764
4765}
4766
4768{
4769 if ((this->getModel()).isModelLinearized()) {
4770 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
4771 } else {
4772 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHZgaRatio());
4773 }
4774}
4775
4776mueeHvvZgaPol::mueeHvvZgaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4777: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4778{
4779 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4780 throw std::runtime_error("mueeHvvZgaPol called with a class whose parent is not NPbase");
4781
4782}
4783
4785{
4786 if ((this->getModel()).isModelLinearized()) {
4787 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZgaRatio()) - 1.0);
4788 } else {
4790 }
4791}
4792
4793mueeHvvgaga::mueeHvvgaga(const StandardModel& SM_i, const double sqrt_s_i)
4794: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4795{
4796 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4797 throw std::runtime_error("mueeHvvgaga called with a class whose parent is not NPbase");
4798
4799}
4800
4802{
4803 if ((this->getModel()).isModelLinearized()) {
4804 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
4805 } else {
4807 }
4808}
4809
4810mueeHvvgagaPol::mueeHvvgagaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4811: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4812{
4813 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4814 throw std::runtime_error("mueeHvvgagaPol called with a class whose parent is not NPbase");
4815
4816}
4817
4819{
4820 if ((this->getModel()).isModelLinearized()) {
4821 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHgagaRatio()) - 1.0);
4822 } else {
4824 }
4825}
4826
4827mueeHvvmumu::mueeHvvmumu(const StandardModel& SM_i, const double sqrt_s_i)
4828: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4829{
4830 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4831 throw std::runtime_error("mueeHvvmumu called with a class whose parent is not NPbase");
4832
4833}
4834
4836{
4837 if ((this->getModel()).isModelLinearized()) {
4838 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
4839 } else {
4841 }
4842}
4843
4844mueeHvvmumuPol::mueeHvvmumuPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4845: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4846{
4847 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4848 throw std::runtime_error("mueeHvvmumuPol called with a class whose parent is not NPbase");
4849
4850}
4851
4853{
4854 if ((this->getModel()).isModelLinearized()) {
4855 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHmumuRatio()) - 1.0);
4856 } else {
4858 }
4859}
4860
4861mueeZBFbb::mueeZBFbb(const StandardModel& SM_i, const double sqrt_s_i)
4862: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4863{
4864 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4865 throw std::runtime_error("mueeZBFbb called with a class whose parent is not NPbase");
4866}
4867
4869{
4870 if ((this->getModel()).isModelLinearized()) {
4871 return ((myNPbase->mueeZBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4872 } else {
4873 return (myNPbase->mueeZBF(sqrt_s))*(myNPbase->BrHbbRatio());
4874 }
4875}
4876
4877mueeZBFbbPol::mueeZBFbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4878: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4879{
4880 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4881 throw std::runtime_error("mueeZBFbbPol called with a class whose parent is not NPbase");
4882}
4883
4885{
4886 if ((this->getModel()).isModelLinearized()) {
4887 return ((myNPbase->mueeZBFPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4888 } else {
4890 }
4891}
4892
4893mueettHbb::mueettHbb(const StandardModel& SM_i, const double sqrt_s_i)
4894: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4895{
4896 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4897 throw std::runtime_error("mueettHbb called with a class whose parent is not NPbase");
4898}
4899
4901{
4902 if ((this->getModel()).isModelLinearized()) {
4903 return ((myNPbase->mueettH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4904 } else {
4905 return (myNPbase->mueettH(sqrt_s))*(myNPbase->BrHbbRatio());
4906 }
4907}
4908
4909mueettHbbPol::mueettHbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4910: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4911{
4912 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4913 throw std::runtime_error("mueettHbbPol called with a class whose parent is not NPbase");
4914}
4915
4917{
4918 if ((this->getModel()).isModelLinearized()) {
4919 return ((myNPbase->mueettHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4920 } else {
4922 }
4923}
4924
4925
4926// Production signal strengths at mu+ mu- colliders
4927// ------------------------------------------------
4928
4929mummZH::mummZH(const StandardModel& SM_i, const double sqrt_s_i)
4930: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4931{
4932 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4933 throw std::runtime_error("mummZH called with a class whose parent is not NPbase");
4934}
4935
4937{
4938 return myNPbase->mummZH(sqrt_s);
4939}
4940
4941
4942mummHvv::mummHvv(const StandardModel& SM_i, const double sqrt_s_i)
4943: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4944{
4945 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4946 throw std::runtime_error("mummHvv called with a class whose parent is not NPbase");
4947}
4948
4950{
4951 return myNPbase->mummHvv(sqrt_s);
4952}
4953
4954
4955mummHmm::mummHmm(const StandardModel& SM_i, const double sqrt_s_i)
4956: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4957{
4958 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4959 throw std::runtime_error("mummHmm called with a class whose parent is not NPbase");
4960}
4961
4963{
4964 return myNPbase->mummHmm(sqrt_s);
4965}
4966
4967
4968mummttH::mummttH(const StandardModel& SM_i, const double sqrt_s_i)
4969: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4970{
4971 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4972 throw std::runtime_error("mummttH called with a class whose parent is not NPbase");
4973}
4974
4976{
4977 return myNPbase->mummttH(sqrt_s);
4978}
4979
4980
4981// Full signal strengths at mu+ mu- colliders
4982// -------------------------------------------
4983
4984
4985mummHbb::mummHbb(const StandardModel& SM_i, const double sqrt_s_i)
4986: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4987{
4988 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4989 throw std::runtime_error("mummHbb called with a class whose parent is not NPbase");
4990}
4991
4993{
4994 if ((this->getModel()).isModelLinearized()) {
4995 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4996 } else {
4997 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHbbRatio());
4998 }
4999}
5000
5001mummHcc::mummHcc(const StandardModel& SM_i, const double sqrt_s_i)
5002: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5003{
5004 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5005 throw std::runtime_error("mummHcc called with a class whose parent is not NPbase");
5006}
5007
5009{
5010 if ((this->getModel()).isModelLinearized()) {
5011 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5012 } else {
5013 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHccRatio());
5014 }
5015}
5016
5017mummHgg::mummHgg(const StandardModel& SM_i, const double sqrt_s_i)
5018: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5019{
5020 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5021 throw std::runtime_error("mummHgg called with a class whose parent is not NPbase");
5022}
5023
5025{
5026 if ((this->getModel()).isModelLinearized()) {
5027 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5028 } else {
5029 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHggRatio());
5030 }
5031}
5032
5033mummHWW::mummHWW(const StandardModel& SM_i, const double sqrt_s_i)
5034: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5035{
5036 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5037 throw std::runtime_error("mummHcc called with a class whose parent is not NPbase");
5038}
5039
5041{
5042 if ((this->getModel()).isModelLinearized()) {
5043 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5044 } else {
5045 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHWWRatio());
5046 }
5047}
5048
5049mummHtautau::mummHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5050: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5051{
5052 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5053 throw std::runtime_error("mummHtautau called with a class whose parent is not NPbase");
5054}
5055
5057{
5058 if ((this->getModel()).isModelLinearized()) {
5059 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5060 } else {
5062 }
5063}
5064
5065mummHZZ::mummHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5066: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5067{
5068 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5069 throw std::runtime_error("mummHZZ called with a class whose parent is not NPbase");
5070}
5071
5073{
5074 if ((this->getModel()).isModelLinearized()) {
5075 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5076 } else {
5077 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHZZRatio());
5078 }
5079}
5080
5081mummHZga::mummHZga(const StandardModel& SM_i, const double sqrt_s_i)
5082: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5083{
5084 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5085 throw std::runtime_error("mummHZga called with a class whose parent is not NPbase");
5086}
5087
5089{
5090 if ((this->getModel()).isModelLinearized()) {
5091 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5092 } else {
5093 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHZgaRatio());
5094 }
5095}
5096
5097mummHgaga::mummHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5098: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5099{
5100 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5101 throw std::runtime_error("mummHgaga called with a class whose parent is not NPbase");
5102}
5103
5105{
5106 if ((this->getModel()).isModelLinearized()) {
5107 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5108 } else {
5109 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHgagaRatio());
5110 }
5111}
5112
5113mummHmumu::mummHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5114: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5115{
5116 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5117 throw std::runtime_error("mummHmumu called with a class whose parent is not NPbase");
5118}
5119
5121{
5122 if ((this->getModel()).isModelLinearized()) {
5123 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5124 } else {
5125 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHmumuRatio());
5126 }
5127}
5128
5129
5130
5131mummZHbb::mummZHbb(const StandardModel& SM_i, const double sqrt_s_i)
5132: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5133{
5134 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5135 throw std::runtime_error("mummZHbb called with a class whose parent is not NPbase");
5136}
5137
5139{
5140 if ((this->getModel()).isModelLinearized()) {
5141 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5142 } else {
5143 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHbbRatio());
5144 }
5145}
5146
5147mummZHcc::mummZHcc(const StandardModel& SM_i, const double sqrt_s_i)
5148: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5149{
5150 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5151 throw std::runtime_error("mummZHcc called with a class whose parent is not NPbase");
5152}
5153
5155{
5156 if ((this->getModel()).isModelLinearized()) {
5157 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5158 } else {
5159 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHccRatio());
5160 }
5161}
5162
5163mummZHgg::mummZHgg(const StandardModel& SM_i, const double sqrt_s_i)
5164: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5165{
5166 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5167 throw std::runtime_error("mummZHgg called with a class whose parent is not NPbase");
5168}
5169
5171{
5172 if ((this->getModel()).isModelLinearized()) {
5173 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5174 } else {
5175 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHggRatio());
5176 }
5177}
5178
5179mummZHWW::mummZHWW(const StandardModel& SM_i, const double sqrt_s_i)
5180: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5181{
5182 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5183 throw std::runtime_error("mummZHcc called with a class whose parent is not NPbase");
5184}
5185
5187{
5188 if ((this->getModel()).isModelLinearized()) {
5189 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5190 } else {
5191 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHWWRatio());
5192 }
5193}
5194
5195mummZHtautau::mummZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5196: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5197{
5198 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5199 throw std::runtime_error("mummZHtautau called with a class whose parent is not NPbase");
5200}
5201
5203{
5204 if ((this->getModel()).isModelLinearized()) {
5205 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5206 } else {
5208 }
5209}
5210
5211mummZHZZ::mummZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5212: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5213{
5214 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5215 throw std::runtime_error("mummZHZZ called with a class whose parent is not NPbase");
5216}
5217
5219{
5220 if ((this->getModel()).isModelLinearized()) {
5221 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5222 } else {
5223 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHZZRatio());
5224 }
5225}
5226
5227mummZHZga::mummZHZga(const StandardModel& SM_i, const double sqrt_s_i)
5228: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5229{
5230 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5231 throw std::runtime_error("mummZHZga called with a class whose parent is not NPbase");
5232}
5233
5235{
5236 if ((this->getModel()).isModelLinearized()) {
5237 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5238 } else {
5239 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHZgaRatio());
5240 }
5241}
5242
5243mummZHgaga::mummZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5244: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5245{
5246 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5247 throw std::runtime_error("mummZHgaga called with a class whose parent is not NPbase");
5248}
5249
5251{
5252 if ((this->getModel()).isModelLinearized()) {
5253 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5254 } else {
5255 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHgagaRatio());
5256 }
5257}
5258
5259mummZHmumu::mummZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5260: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5261{
5262 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5263 throw std::runtime_error("mummZHmumu called with a class whose parent is not NPbase");
5264}
5265
5267{
5268 if ((this->getModel()).isModelLinearized()) {
5269 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5270 } else {
5271 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHmumuRatio());
5272 }
5273}
5274
5275
5276
5277mummHvvbb::mummHvvbb(const StandardModel& SM_i, const double sqrt_s_i)
5278: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5279{
5280 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5281 throw std::runtime_error("mummHvvbb called with a class whose parent is not NPbase");
5282}
5283
5285{
5286 if ((this->getModel()).isModelLinearized()) {
5287 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5288 } else {
5289 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHbbRatio());
5290 }
5291}
5292
5293mummHvvcc::mummHvvcc(const StandardModel& SM_i, const double sqrt_s_i)
5294: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5295{
5296 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5297 throw std::runtime_error("mummHvvcc called with a class whose parent is not NPbase");
5298}
5299
5301{
5302 if ((this->getModel()).isModelLinearized()) {
5303 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5304 } else {
5305 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHccRatio());
5306 }
5307}
5308
5309mummHvvgg::mummHvvgg(const StandardModel& SM_i, const double sqrt_s_i)
5310: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5311{
5312 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5313 throw std::runtime_error("mummHvvgg called with a class whose parent is not NPbase");
5314}
5315
5317{
5318 if ((this->getModel()).isModelLinearized()) {
5319 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5320 } else {
5321 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHggRatio());
5322 }
5323}
5324
5325mummHvvWW::mummHvvWW(const StandardModel& SM_i, const double sqrt_s_i)
5326: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5327{
5328 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5329 throw std::runtime_error("mummHvvcc called with a class whose parent is not NPbase");
5330}
5331
5333{
5334 if ((this->getModel()).isModelLinearized()) {
5335 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5336 } else {
5337 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHWWRatio());
5338 }
5339}
5340
5341mummHvvtautau::mummHvvtautau(const StandardModel& SM_i, const double sqrt_s_i)
5342: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5343{
5344 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5345 throw std::runtime_error("mummHvvtautau called with a class whose parent is not NPbase");
5346}
5347
5349{
5350 if ((this->getModel()).isModelLinearized()) {
5351 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5352 } else {
5354 }
5355}
5356
5357mummHvvZZ::mummHvvZZ(const StandardModel& SM_i, const double sqrt_s_i)
5358: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5359{
5360 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5361 throw std::runtime_error("mummHvvZZ called with a class whose parent is not NPbase");
5362}
5363
5365{
5366 if ((this->getModel()).isModelLinearized()) {
5367 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5368 } else {
5369 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHZZRatio());
5370 }
5371}
5372
5373mummHvvZga::mummHvvZga(const StandardModel& SM_i, const double sqrt_s_i)
5374: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5375{
5376 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5377 throw std::runtime_error("mummHvvZga called with a class whose parent is not NPbase");
5378}
5379
5381{
5382 if ((this->getModel()).isModelLinearized()) {
5383 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5384 } else {
5385 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHZgaRatio());
5386 }
5387}
5388
5389mummHvvgaga::mummHvvgaga(const StandardModel& SM_i, const double sqrt_s_i)
5390: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5391{
5392 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5393 throw std::runtime_error("mummHvvgaga called with a class whose parent is not NPbase");
5394}
5395
5397{
5398 if ((this->getModel()).isModelLinearized()) {
5399 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5400 } else {
5402 }
5403}
5404
5405mummHvvmumu::mummHvvmumu(const StandardModel& SM_i, const double sqrt_s_i)
5406: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5407{
5408 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5409 throw std::runtime_error("mummHvvmumu called with a class whose parent is not NPbase");
5410}
5411
5413{
5414 if ((this->getModel()).isModelLinearized()) {
5415 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5416 } else {
5418 }
5419}
5420
5421
5422
5423mummHmmbb::mummHmmbb(const StandardModel& SM_i, const double sqrt_s_i)
5424: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5425{
5426 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5427 throw std::runtime_error("mummHmmbb called with a class whose parent is not NPbase");
5428}
5429
5431{
5432 if ((this->getModel()).isModelLinearized()) {
5433 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5434 } else {
5435 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHbbRatio());
5436 }
5437}
5438
5439mummHmmcc::mummHmmcc(const StandardModel& SM_i, const double sqrt_s_i)
5440: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5441{
5442 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5443 throw std::runtime_error("mummHmmcc called with a class whose parent is not NPbase");
5444}
5445
5447{
5448 if ((this->getModel()).isModelLinearized()) {
5449 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5450 } else {
5451 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHccRatio());
5452 }
5453}
5454
5455mummHmmgg::mummHmmgg(const StandardModel& SM_i, const double sqrt_s_i)
5456: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5457{
5458 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5459 throw std::runtime_error("mummHmmgg called with a class whose parent is not NPbase");
5460}
5461
5463{
5464 if ((this->getModel()).isModelLinearized()) {
5465 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5466 } else {
5467 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHggRatio());
5468 }
5469}
5470
5471mummHmmWW::mummHmmWW(const StandardModel& SM_i, const double sqrt_s_i)
5472: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5473{
5474 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5475 throw std::runtime_error("mummHmmcc called with a class whose parent is not NPbase");
5476}
5477
5479{
5480 if ((this->getModel()).isModelLinearized()) {
5481 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5482 } else {
5483 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHWWRatio());
5484 }
5485}
5486
5487mummHmmtautau::mummHmmtautau(const StandardModel& SM_i, const double sqrt_s_i)
5488: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5489{
5490 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5491 throw std::runtime_error("mummHmmtautau called with a class whose parent is not NPbase");
5492}
5493
5495{
5496 if ((this->getModel()).isModelLinearized()) {
5497 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5498 } else {
5500 }
5501}
5502
5503mummHmmZZ::mummHmmZZ(const StandardModel& SM_i, const double sqrt_s_i)
5504: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5505{
5506 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5507 throw std::runtime_error("mummHmmZZ called with a class whose parent is not NPbase");
5508}
5509
5511{
5512 if ((this->getModel()).isModelLinearized()) {
5513 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5514 } else {
5515 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHZZRatio());
5516 }
5517}
5518
5519mummHmmZga::mummHmmZga(const StandardModel& SM_i, const double sqrt_s_i)
5520: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5521{
5522 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5523 throw std::runtime_error("mummHmmZga called with a class whose parent is not NPbase");
5524}
5525
5527{
5528 if ((this->getModel()).isModelLinearized()) {
5529 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5530 } else {
5531 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHZgaRatio());
5532 }
5533}
5534
5535mummHmmgaga::mummHmmgaga(const StandardModel& SM_i, const double sqrt_s_i)
5536: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5537{
5538 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5539 throw std::runtime_error("mummHmmgaga called with a class whose parent is not NPbase");
5540}
5541
5543{
5544 if ((this->getModel()).isModelLinearized()) {
5545 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5546 } else {
5548 }
5549}
5550
5551mummHmmmumu::mummHmmmumu(const StandardModel& SM_i, const double sqrt_s_i)
5552: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5553{
5554 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5555 throw std::runtime_error("mummHmmmumu called with a class whose parent is not NPbase");
5556}
5557
5559{
5560 if ((this->getModel()).isModelLinearized()) {
5561 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5562 } else {
5564 }
5565}
5566
5567
5568mummttHbb::mummttHbb(const StandardModel& SM_i, const double sqrt_s_i)
5569: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5570{
5571 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5572 throw std::runtime_error("mummttHbb called with a class whose parent is not NPbase");
5573}
5574
5576{
5577 if ((this->getModel()).isModelLinearized()) {
5578 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5579 } else {
5580 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHbbRatio());
5581 }
5582}
5583
5584mummttHcc::mummttHcc(const StandardModel& SM_i, const double sqrt_s_i)
5585: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5586{
5587 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5588 throw std::runtime_error("mummttHcc called with a class whose parent is not NPbase");
5589}
5590
5592{
5593 if ((this->getModel()).isModelLinearized()) {
5594 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5595 } else {
5596 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHccRatio());
5597 }
5598}
5599
5600mummttHgg::mummttHgg(const StandardModel& SM_i, const double sqrt_s_i)
5601: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5602{
5603 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5604 throw std::runtime_error("mummttHgg called with a class whose parent is not NPbase");
5605}
5606
5608{
5609 if ((this->getModel()).isModelLinearized()) {
5610 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5611 } else {
5612 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHggRatio());
5613 }
5614}
5615
5616mummttHWW::mummttHWW(const StandardModel& SM_i, const double sqrt_s_i)
5617: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5618{
5619 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5620 throw std::runtime_error("mummttHcc called with a class whose parent is not NPbase");
5621}
5622
5624{
5625 if ((this->getModel()).isModelLinearized()) {
5626 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5627 } else {
5628 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHWWRatio());
5629 }
5630}
5631
5632mummttHtautau::mummttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5633: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5634{
5635 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5636 throw std::runtime_error("mummttHtautau called with a class whose parent is not NPbase");
5637}
5638
5640{
5641 if ((this->getModel()).isModelLinearized()) {
5642 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5643 } else {
5645 }
5646}
5647
5648mummttHZZ::mummttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5649: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5650{
5651 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5652 throw std::runtime_error("mummttHZZ called with a class whose parent is not NPbase");
5653}
5654
5656{
5657 if ((this->getModel()).isModelLinearized()) {
5658 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5659 } else {
5660 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHZZRatio());
5661 }
5662}
5663
5664mummttHZga::mummttHZga(const StandardModel& SM_i, const double sqrt_s_i)
5665: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5666{
5667 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5668 throw std::runtime_error("mummttHZga called with a class whose parent is not NPbase");
5669}
5670
5672{
5673 if ((this->getModel()).isModelLinearized()) {
5674 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5675 } else {
5676 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHZgaRatio());
5677 }
5678}
5679
5680mummttHgaga::mummttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5681: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5682{
5683 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5684 throw std::runtime_error("mummttHgaga called with a class whose parent is not NPbase");
5685}
5686
5688{
5689 if ((this->getModel()).isModelLinearized()) {
5690 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5691 } else {
5693 }
5694}
5695
5696mummttHmumu::mummttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5697: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5698{
5699 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5700 throw std::runtime_error("mummttHmumu called with a class whose parent is not NPbase");
5701}
5702
5704{
5705 if ((this->getModel()).isModelLinearized()) {
5706 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5707 } else {
5709 }
5710}
5711
5712
5713// The same in the narrow width approximation
5714
5715mummHbbNWA::mummHbbNWA(const StandardModel& SM_i, const double sqrt_s_i)
5716: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5717{
5718 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5719 throw std::runtime_error("mummHbbNWA called with a class whose parent is not NPbase");
5720}
5721
5723{
5724 if ((this->getModel()).isModelLinearized()) {
5725 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5726 } else {
5727 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHbbRatio());
5728 }
5729}
5730
5731mummHccNWA::mummHccNWA(const StandardModel& SM_i, const double sqrt_s_i)
5732: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5733{
5734 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5735 throw std::runtime_error("mummHccNWA called with a class whose parent is not NPbase");
5736}
5737
5739{
5740 if ((this->getModel()).isModelLinearized()) {
5741 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5742 } else {
5743 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHccRatio());
5744 }
5745}
5746
5747mummHggNWA::mummHggNWA(const StandardModel& SM_i, const double sqrt_s_i)
5748: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5749{
5750 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5751 throw std::runtime_error("mummHggNWA called with a class whose parent is not NPbase");
5752}
5753
5755{
5756 if ((this->getModel()).isModelLinearized()) {
5757 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5758 } else {
5759 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHggRatio());
5760 }
5761}
5762
5763mummHWWNWA::mummHWWNWA(const StandardModel& SM_i, const double sqrt_s_i)
5764: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5765{
5766 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5767 throw std::runtime_error("mummHccNWA called with a class whose parent is not NPbase");
5768}
5769
5771{
5772 if ((this->getModel()).isModelLinearized()) {
5773 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5774 } else {
5775 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHWWRatio());
5776 }
5777}
5778
5779mummHtautauNWA::mummHtautauNWA(const StandardModel& SM_i, const double sqrt_s_i)
5780: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5781{
5782 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5783 throw std::runtime_error("mummHtautauNWA called with a class whose parent is not NPbase");
5784}
5785
5787{
5788 if ((this->getModel()).isModelLinearized()) {
5789 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5790 } else {
5792 }
5793}
5794
5795mummHZZNWA::mummHZZNWA(const StandardModel& SM_i, const double sqrt_s_i)
5796: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5797{
5798 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5799 throw std::runtime_error("mummHZZNWA called with a class whose parent is not NPbase");
5800}
5801
5803{
5804 if ((this->getModel()).isModelLinearized()) {
5805 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5806 } else {
5807 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHZZRatio());
5808 }
5809}
5810
5811mummHZgaNWA::mummHZgaNWA(const StandardModel& SM_i, const double sqrt_s_i)
5812: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5813{
5814 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5815 throw std::runtime_error("mummHZgaNWA called with a class whose parent is not NPbase");
5816}
5817
5819{
5820 if ((this->getModel()).isModelLinearized()) {
5821 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5822 } else {
5824 }
5825}
5826
5827mummHgagaNWA::mummHgagaNWA(const StandardModel& SM_i, const double sqrt_s_i)
5828: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5829{
5830 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5831 throw std::runtime_error("mummHgagaNWA called with a class whose parent is not NPbase");
5832}
5833
5835{
5836 if ((this->getModel()).isModelLinearized()) {
5837 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5838 } else {
5840 }
5841}
5842
5843mummHmumuNWA::mummHmumuNWA(const StandardModel& SM_i, const double sqrt_s_i)
5844: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5845{
5846 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5847 throw std::runtime_error("mummHmumuNWA called with a class whose parent is not NPbase");
5848}
5849
5851{
5852 if ((this->getModel()).isModelLinearized()) {
5853 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5854 } else {
5856 }
5857}
5858
5859// Full signal strengths at ep colliders
5860// -------------------------------------
5861
5862muepWBFbb::muepWBFbb(const StandardModel& SM_i, const double sqrt_s_i)
5863: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5864{
5865 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5866 throw std::runtime_error("muepWBFbb called with a class whose parent is not NPbase");
5867
5868}
5869
5871{
5872 if ((this->getModel()).isModelLinearized()) {
5873 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5874 } else {
5875 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHbbRatio());
5876 }
5877}
5878
5879muepWBFcc::muepWBFcc(const StandardModel& SM_i, const double sqrt_s_i)
5880: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5881{
5882 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5883 throw std::runtime_error("muepWBFcc called with a class whose parent is not NPbase");
5884
5885}
5886
5888{
5889 if ((this->getModel()).isModelLinearized()) {
5890 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5891 } else {
5892 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHccRatio());
5893 }
5894}
5895
5896muepWBFgg::muepWBFgg(const StandardModel& SM_i, const double sqrt_s_i)
5897: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5898{
5899 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5900 throw std::runtime_error("muepWBFgg called with a class whose parent is not NPbase");
5901
5902}
5903
5905{
5906 if ((this->getModel()).isModelLinearized()) {
5907 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5908 } else {
5909 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHggRatio());
5910 }
5911}
5912
5913muepWBFWW2l2v::muepWBFWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
5914: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5915{
5916 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5917 throw std::runtime_error("muepWBFWW2l2v called with a class whose parent is not NPbase");
5918
5919}
5920
5922{
5923 if ((this->getModel()).isModelLinearized()) {
5924 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()) - 1.0);
5925 } else {
5927 }
5928}
5929
5930muepWBFZZ4l::muepWBFZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
5931: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5932{
5933 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5934 throw std::runtime_error("muepWBFZZ4l called with a class whose parent is not NPbase");
5935
5936}
5937
5939{
5940 if ((this->getModel()).isModelLinearized()) {
5941 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
5942 } else {
5943 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrH4lRatio());
5944 }
5945}
5946
5947muepWBFgaga::muepWBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
5948: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5949{
5950 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5951 throw std::runtime_error("muepWBFgaga called with a class whose parent is not NPbase");
5952
5953}
5954
5956{
5957 if ((this->getModel()).isModelLinearized()) {
5958 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5959 } else {
5961 }
5962}
5963
5964muepWBFtautau::muepWBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
5965: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5966{
5967 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5968 throw std::runtime_error("muepWBFtautau called with a class whose parent is not NPbase");
5969
5970}
5971
5973{
5974 if ((this->getModel()).isModelLinearized()) {
5975 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5976 } else {
5978 }
5979}
5980
5981muepZBFbb::muepZBFbb(const StandardModel& SM_i, const double sqrt_s_i)
5982: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5983{
5984 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5985 throw std::runtime_error("muepZBFbb called with a class whose parent is not NPbase");
5986
5987}
5988
5990{
5991 if ((this->getModel()).isModelLinearized()) {
5992 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5993 } else {
5994 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHbbRatio());
5995 }
5996}
5997
5998muepZBFcc::muepZBFcc(const StandardModel& SM_i, const double sqrt_s_i)
5999: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6000{
6001 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6002 throw std::runtime_error("muepZBFcc called with a class whose parent is not NPbase");
6003
6004}
6005
6007{
6008 if ((this->getModel()).isModelLinearized()) {
6009 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
6010 } else {
6011 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHccRatio());
6012 }
6013}
6014
6015muepZBFgg::muepZBFgg(const StandardModel& SM_i, const double sqrt_s_i)
6016: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6017{
6018 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6019 throw std::runtime_error("muepZBFgg called with a class whose parent is not NPbase");
6020
6021}
6022
6024{
6025 if ((this->getModel()).isModelLinearized()) {
6026 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
6027 } else {
6028 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHggRatio());
6029 }
6030}
6031
6032muepZBFWW2l2v::muepZBFWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
6033: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6034{
6035 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6036 throw std::runtime_error("muepZBFWW2l2v called with a class whose parent is not NPbase");
6037
6038}
6039
6041{
6042 if ((this->getModel()).isModelLinearized()) {
6043 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()) - 1.0);
6044 } else {
6046 }
6047}
6048
6049muepZBFZZ4l::muepZBFZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
6050: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6051{
6052 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6053 throw std::runtime_error("muepZBFZZ4l called with a class whose parent is not NPbase");
6054
6055}
6056
6058{
6059 if ((this->getModel()).isModelLinearized()) {
6060 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6061 } else {
6062 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrH4lRatio());
6063 }
6064}
6065
6066muepZBFgaga::muepZBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
6067: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6068{
6069 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6070 throw std::runtime_error("muepZBFgaga called with a class whose parent is not NPbase");
6071
6072}
6073
6075{
6076 if ((this->getModel()).isModelLinearized()) {
6077 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
6078 } else {
6080 }
6081}
6082
6083muepZBFtautau::muepZBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
6084: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6085{
6086 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6087 throw std::runtime_error("muepZBFtautau called with a class whose parent is not NPbase");
6088
6089}
6090
6092{
6093 if ((this->getModel()).isModelLinearized()) {
6094 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
6095 } else {
6097 }
6098}
6099
6100
6101// -----------------------------------------------------------------------------
6102// STXS bins
6103// -----------------------------------------------------------------------------
6104
6105// -----------------------------------------------------------------------------
6106// Stage 0
6107// -----------------------------------------------------------------------------
6108
6109STXS_0_qqH::STXS_0_qqH(const StandardModel& SM_i, const double sqrt_s_i)
6110: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6111{
6112 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6113 throw std::runtime_error("STXS_0_qqH called with a class whose parent is not NPbase");
6114
6115}
6116
6118{
6119 return myNPbase->STXS0_qqH(sqrt_s);
6120}
6121
6122
6123// -----------------------------------------------------------------------------
6124// Stage 1
6125// -----------------------------------------------------------------------------
6126
6128: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6129{
6130 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6131 throw std::runtime_error("STXSggH_VBFtopo_j3v_4l called with a class whose parent is not NPbase");
6132
6133}
6134
6136{
6137 if ((this->getModel()).isModelLinearized()) {
6138 return ((myNPbase->STXS_ggH_VBFtopo_j3v(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6139 } else {
6141 }
6142}
6143
6144
6146: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6147{
6148 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6149 throw std::runtime_error("STXSggH_VBFtopo_j3_4l called with a class whose parent is not NPbase");
6150
6151}
6152
6154{
6155 if ((this->getModel()).isModelLinearized()) {
6156 return ((myNPbase->STXS_ggH_VBFtopo_j3(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6157 } else {
6159 }
6160}
6161
6162
6163STXSggH0j4l::STXSggH0j4l(const StandardModel& SM_i, const double sqrt_s_i)
6164: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6165{
6166 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6167 throw std::runtime_error("STXSggH0j4l called with a class whose parent is not NPbase");
6168
6169}
6170
6172{
6173 if ((this->getModel()).isModelLinearized()) {
6174 return ((myNPbase->STXS_ggH0j(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6175 } else {
6177 }
6178}
6179
6181: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6182{
6183 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6184 throw std::runtime_error("STXSggH1j_pTH_0_60_4l called with a class whose parent is not NPbase");
6185
6186}
6187
6189{
6190 if ((this->getModel()).isModelLinearized()) {
6191 return ((myNPbase->STXS_ggH1j_pTH_0_60(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6192 } else {
6194 }
6195}
6196
6198: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6199{
6200 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6201 throw std::runtime_error("STXSggH1j_pTH_60_120_4l called with a class whose parent is not NPbase");
6202
6203}
6204
6206{
6207 if ((this->getModel()).isModelLinearized()) {
6208 return ((myNPbase->STXS_ggH1j_pTH_60_120(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6209 } else {
6211 }
6212}
6213
6215: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6216{
6217 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6218 throw std::runtime_error("STXSggH1j_pTH_120_200_4l called with a class whose parent is not NPbase");
6219
6220}
6221
6223{
6224 if ((this->getModel()).isModelLinearized()) {
6225 return ((myNPbase->STXS_ggH1j_pTH_120_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6226 } else {
6228 }
6229}
6230
6232: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6233{
6234 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6235 throw std::runtime_error("STXSggH1j_pTH_200_4l called with a class whose parent is not NPbase");
6236
6237}
6238
6240{
6241 if ((this->getModel()).isModelLinearized()) {
6242 return ((myNPbase->STXS_ggH1j_pTH_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6243 } else {
6245 }
6246}
6247
6249: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6250{
6251 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6252 throw std::runtime_error("STXSggH2j_pTH_0_200_4l called with a class whose parent is not NPbase");
6253
6254}
6255
6257{
6258 if ((this->getModel()).isModelLinearized()) {
6259 return ((myNPbase->STXS_ggH2j_pTH_0_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6260 } else {
6262 }
6263}
6264
6265
6267: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6268{
6269 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6270 throw std::runtime_error("STXSggH2j_pTH_0_60_4l called with a class whose parent is not NPbase");
6271
6272}
6273
6275{
6276 if ((this->getModel()).isModelLinearized()) {
6277 return ((myNPbase->STXS_ggH2j_pTH_0_60(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6278 } else {
6280 }
6281}
6282
6283
6285: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6286{
6287 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6288 throw std::runtime_error("STXSggH2j_pTH_60_120_4l called with a class whose parent is not NPbase");
6289
6290}
6291
6293{
6294 if ((this->getModel()).isModelLinearized()) {
6295 return ((myNPbase->STXS_ggH2j_pTH_60_120(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6296 } else {
6298 }
6299}
6300
6301
6303: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6304{
6305 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6306 throw std::runtime_error("STXSggH2j_pTH_120_200_4l called with a class whose parent is not NPbase");
6307
6308}
6309
6311{
6312 if ((this->getModel()).isModelLinearized()) {
6313 return ((myNPbase->STXS_ggH2j_pTH_120_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6314 } else {
6316 }
6317}
6318
6319
6321: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6322{
6323 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6324 throw std::runtime_error("STXSggH2j_pTH_200_4l called with a class whose parent is not NPbase");
6325
6326}
6327
6329{
6330 if ((this->getModel()).isModelLinearized()) {
6331 return ((myNPbase->STXS_ggH2j_pTH_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6332 } else {
6334 }
6335}
6336
6337
6339: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6340{
6341 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6342 throw std::runtime_error("STXSqqHqq_VBFtopo_Rest_4l called with a class whose parent is not NPbase");
6343
6344}
6345
6347{
6348 if ((this->getModel()).isModelLinearized()) {
6349 return ((myNPbase->STXS_qqHqq_VBFtopo_Rest(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6350 } else {
6352 }
6353}
6354
6355
6357: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6358{
6359 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6360 throw std::runtime_error("STXSqqHqq_VBFtopo_j3v_4l called with a class whose parent is not NPbase");
6361
6362}
6363
6365{
6366 if ((this->getModel()).isModelLinearized()) {
6367 return ((myNPbase->STXS_qqHqq_VBFtopo_j3v(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6368 } else {
6370 }
6371}
6372
6373
6374
6376: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6377{
6378 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6379 throw std::runtime_error("STXSqqHqq_VBFtopo_j3_4l called with a class whose parent is not NPbase");
6380
6381}
6382
6384{
6385 if ((this->getModel()).isModelLinearized()) {
6386 return ((myNPbase->STXS_qqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6387 } else {
6389 }
6390}
6391
6392
6393
6395: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6396{
6397 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6398 throw std::runtime_error("STXSqqHqq_nonVHtopo_4l called with a class whose parent is not NPbase");
6399
6400}
6401
6403{
6404 if ((this->getModel()).isModelLinearized()) {
6405 return ((myNPbase->STXS_qqHqq_nonVHtopo(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6406 } else {
6408 }
6409}
6410
6411
6412
6414: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6415{
6416 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6417 throw std::runtime_error("STXSqqHqq_VHtopo_4l called with a class whose parent is not NPbase");
6418
6419}
6420
6422{
6423 if ((this->getModel()).isModelLinearized()) {
6424 return ((myNPbase->STXS_qqHqq_VHtopo(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6425 } else {
6427 }
6428}
6429
6430
6431STXSqqHqq_Rest_4l::STXSqqHqq_Rest_4l(const StandardModel& SM_i, const double sqrt_s_i)
6432: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6433{
6434 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6435 throw std::runtime_error("STXSqqHqq_Rest_4l called with a class whose parent is not NPbase");
6436
6437}
6438
6440{
6441 if ((this->getModel()).isModelLinearized()) {
6442 return ((myNPbase->STXS_qqHqq_Rest(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6443 } else {
6445 }
6446}
6447
6448
6450: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6451{
6452 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6453 throw std::runtime_error("STXSqqHqq_pTj_200_4l called with a class whose parent is not NPbase");
6454
6455}
6456
6458{
6459 if ((this->getModel()).isModelLinearized()) {
6460 return ((myNPbase->STXS_qqHqq_pTj_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6461 } else {
6463 }
6464}
6465
6467: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6468{
6469 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6470 throw std::runtime_error("STXSqqHlv_pTV_0_250_4l called with a class whose parent is not NPbase");
6471
6472}
6473
6475{
6476 if ((this->getModel()).isModelLinearized()) {
6477 return ((myNPbase->STXS_qqHlv_pTV_0_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6478 } else {
6480 }
6481}
6482
6483
6485: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6486{
6487 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6488 throw std::runtime_error("STXSqqHlv_pTV_0_150_4l called with a class whose parent is not NPbase");
6489
6490}
6491
6493{
6494 if ((this->getModel()).isModelLinearized()) {
6495 return ((myNPbase->STXS_qqHlv_pTV_0_150(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6496 } else {
6498 }
6499}
6500
6501
6502
6504: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6505{
6506 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6507 throw std::runtime_error("STXSqqHlv_pTV_150_250_0j_4l called with a class whose parent is not NPbase");
6508
6509}
6510
6512{
6513 if ((this->getModel()).isModelLinearized()) {
6515 } else {
6517 }
6518}
6519
6520
6521
6523: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6524{
6525 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6526 throw std::runtime_error("STXSqqHlv_pTV_150_250_1j_4l called with a class whose parent is not NPbase");
6527
6528}
6529
6531{
6532 if ((this->getModel()).isModelLinearized()) {
6534 } else {
6536 }
6537}
6538
6539
6541: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6542{
6543 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6544 throw std::runtime_error("STXSqqHlv_pTV_250_4l called with a class whose parent is not NPbase");
6545
6546}
6547
6549{
6550 if ((this->getModel()).isModelLinearized()) {
6551 return ((myNPbase->STXS_qqHlv_pTV_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6552 } else {
6554 }
6555}
6556
6558: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6559{
6560 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6561 throw std::runtime_error("STXSqqHll_pTV_0_150_4l called with a class whose parent is not NPbase");
6562
6563}
6564
6566{
6567 if ((this->getModel()).isModelLinearized()) {
6568 return ((myNPbase->STXS_qqHll_pTV_0_150(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6569 } else {
6571 }
6572}
6573
6575: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6576{
6577 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6578 throw std::runtime_error("STXSqqHll_pTV_150_250_4l called with a class whose parent is not NPbase");
6579
6580}
6581
6583{
6584 if ((this->getModel()).isModelLinearized()) {
6585 return ((myNPbase->STXS_qqHll_pTV_150_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6586 } else {
6588 }
6589}
6590
6591
6593: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6594{
6595 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6596 throw std::runtime_error("STXSqqHll_pTV_150_250_0j_4l called with a class whose parent is not NPbase");
6597
6598}
6599
6601{
6602 if ((this->getModel()).isModelLinearized()) {
6604 } else {
6606 }
6607}
6608
6609
6611: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6612{
6613 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6614 throw std::runtime_error("STXSqqHll_pTV_150_250_1j_4l called with a class whose parent is not NPbase");
6615
6616}
6617
6619{
6620 if ((this->getModel()).isModelLinearized()) {
6622 } else {
6624 }
6625}
6626
6627
6629: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6630{
6631 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6632 throw std::runtime_error("STXSqqHll_pTV_250_4l called with a class whose parent is not NPbase");
6633
6634}
6635
6637{
6638 if ((this->getModel()).isModelLinearized()) {
6639 return ((myNPbase->STXS_qqHll_pTV_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6640 } else {
6642 }
6643}
6644
6645STXSttHtH4l::STXSttHtH4l(const StandardModel& SM_i, const double sqrt_s_i)
6646: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6647{
6648 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6649 throw std::runtime_error("STXSttHtH4l called with a class whose parent is not NPbase");
6650
6651}
6652
6654{
6655 if ((this->getModel()).isModelLinearized()) {
6656 return ((myNPbase->STXS_ttHtH(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6657 } else {
6659 }
6660}
6661
6662
6664: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6665{
6666 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6667 throw std::runtime_error("STXSqqHlv_pTV_0_250_bb called with a class whose parent is not NPbase");
6668
6669}
6670
6672{
6673 if ((this->getModel()).isModelLinearized()) {
6674 return ((myNPbase->STXS_qqHlv_pTV_0_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6675 } else {
6677 }
6678}
6679
6680
6682: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6683{
6684 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6685 throw std::runtime_error("STXSqqHlv_pTV_0_150_bb called with a class whose parent is not NPbase");
6686
6687}
6688
6690{
6691 if ((this->getModel()).isModelLinearized()) {
6692 return ((myNPbase->STXS_qqHlv_pTV_0_150(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6693 } else {
6695 }
6696}
6697
6698
6699
6701: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6702{
6703 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6704 throw std::runtime_error("STXSqqHlv_pTV_150_250_0j_bb called with a class whose parent is not NPbase");
6705
6706}
6707
6709{
6710 if ((this->getModel()).isModelLinearized()) {
6712 } else {
6714 }
6715}
6716
6717
6718
6720: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6721{
6722 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6723 throw std::runtime_error("STXSqqHlv_pTV_150_250_1j_bb called with a class whose parent is not NPbase");
6724
6725}
6726
6728{
6729 if ((this->getModel()).isModelLinearized()) {
6731 } else {
6733 }
6734}
6735
6736
6738: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6739{
6740 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6741 throw std::runtime_error("STXSqqHlv_pTV_250_bb called with a class whose parent is not NPbase");
6742
6743}
6744
6746{
6747 if ((this->getModel()).isModelLinearized()) {
6748 return ((myNPbase->STXS_qqHlv_pTV_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6749 } else {
6751 }
6752}
6753
6755: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6756{
6757 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6758 throw std::runtime_error("STXSqqHll_pTV_0_150_bb called with a class whose parent is not NPbase");
6759
6760}
6761
6763{
6764 if ((this->getModel()).isModelLinearized()) {
6765 return ((myNPbase->STXS_qqHll_pTV_0_150(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6766 } else {
6768 }
6769}
6770
6772: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6773{
6774 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6775 throw std::runtime_error("STXSqqHll_pTV_150_250_bb called with a class whose parent is not NPbase");
6776
6777}
6778
6780{
6781 if ((this->getModel()).isModelLinearized()) {
6782 return ((myNPbase->STXS_qqHll_pTV_150_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6783 } else {
6785 }
6786}
6787
6788
6790: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6791{
6792 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6793 throw std::runtime_error("STXSqqHll_pTV_150_250_0j_bb called with a class whose parent is not NPbase");
6794
6795}
6796
6798{
6799 if ((this->getModel()).isModelLinearized()) {
6801 } else {
6803 }
6804}
6805
6806
6808: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6809{
6810 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6811 throw std::runtime_error("STXSqqHll_pTV_150_250_1j_bb called with a class whose parent is not NPbase");
6812
6813}
6814
6816{
6817 if ((this->getModel()).isModelLinearized()) {
6819 } else {
6821 }
6822}
6823
6824
6826: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6827{
6828 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6829 throw std::runtime_error("STXSqqHll_pTV_250_bb called with a class whose parent is not NPbase");
6830
6831}
6832
6834{
6835 if ((this->getModel()).isModelLinearized()) {
6836 return ((myNPbase->STXS_qqHll_pTV_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6837 } else {
6839 }
6840}
6841
6842
6844: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6845{
6846 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6847 throw std::runtime_error("STXSWHqqHqq_VBFtopo_j3v_2b called with a class whose parent is not NPbase");
6848
6849}
6850
6852{
6853 if ((this->getModel()).isModelLinearized()) {
6855 } else {
6857 }
6858}
6859
6860
6862: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6863{
6864 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6865 throw std::runtime_error("STXSWHqqHqq_VBFtopo_j3_2b called with a class whose parent is not NPbase");
6866
6867}
6868
6870{
6871 if ((this->getModel()).isModelLinearized()) {
6872 return ((myNPbase->STXS_WHqqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6873 } else {
6875 }
6876}
6877
6878
6880: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6881{
6882 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6883 throw std::runtime_error("STXSWHqqHqq_VH2j_2b called with a class whose parent is not NPbase");
6884
6885}
6886
6888{
6889 if ((this->getModel()).isModelLinearized()) {
6890 return ((myNPbase->STXS_WHqqHqq_VH2j(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6891 } else {
6893 }
6894}
6895
6896
6898: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6899{
6900 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6901 throw std::runtime_error("STXSWHqqHqq_Rest_2b called with a class whose parent is not NPbase");
6902
6903}
6904
6906{
6907 if ((this->getModel()).isModelLinearized()) {
6908 return ((myNPbase->STXS_WHqqHqq_Rest(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6909 } else {
6911 }
6912}
6913
6914
6916: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6917{
6918 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6919 throw std::runtime_error("STXSWHqqHqq_pTj1_200_2b called with a class whose parent is not NPbase");
6920
6921}
6922
6924{
6925 if ((this->getModel()).isModelLinearized()) {
6926 return ((myNPbase->STXS_WHqqHqq_pTj1_200(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6927 } else {
6929 }
6930}
6931
6932
6934: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6935{
6936 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6937 throw std::runtime_error("STXSZHqqHqq_VBFtopo_j3v_2b called with a class whose parent is not NPbase");
6938
6939}
6940
6942{
6943 if ((this->getModel()).isModelLinearized()) {
6945 } else {
6947 }
6948}
6949
6950
6952: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6953{
6954 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6955 throw std::runtime_error("STXSZHqqHqq_VBFtopo_j3_2b called with a class whose parent is not NPbase");
6956
6957}
6958
6960{
6961 if ((this->getModel()).isModelLinearized()) {
6962 return ((myNPbase->STXS_ZHqqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6963 } else {
6965 }
6966}
6967
6968
6970: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6971{
6972 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6973 throw std::runtime_error("STXSZHqqHqq_VH2j_2b called with a class whose parent is not NPbase");
6974
6975}
6976
6978{
6979 if ((this->getModel()).isModelLinearized()) {
6980 return ((myNPbase->STXS_ZHqqHqq_VH2j(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6981 } else {
6983 }
6984}
6985
6986
6988: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6989{
6990 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6991 throw std::runtime_error("STXSZHqqHqq_Rest_2b called with a class whose parent is not NPbase");
6992
6993}
6994
6996{
6997 if ((this->getModel()).isModelLinearized()) {
6998 return ((myNPbase->STXS_ZHqqHqq_Rest(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6999 } else {
7001 }
7002}
7003
7004
7006: ThObservable(SM_i), sqrt_s(sqrt_s_i)
7007{
7008 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7009 throw std::runtime_error("STXSZHqqHqq_pTj1_200_2b called with a class whose parent is not NPbase");
7010
7011}
7012
7014{
7015 if ((this->getModel()).isModelLinearized()) {
7016 return ((myNPbase->STXS_ZHqqHqq_pTj1_200(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
7017 } else {
7019 }
7020}
7021
7022
7023
7024// -----------------------------------------------------------------------------
7025// Stage 1.2
7026// -----------------------------------------------------------------------------
7027
7028STXS12_ggH_pTH200_300_Nj01::STXS12_ggH_pTH200_300_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7029: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7030{
7031 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7032 throw std::runtime_error("STXS12_ggH_pTH200_300_Nj01 called with a class whose parent is not NPbase");
7033
7034}
7035
7037{
7038 double BrHXXRatio = 1.0;
7039 if (fstate == 1){
7040 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7041 } else if (fstate == 2){
7042 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7043 } else if (fstate == 3){
7044 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7045 } else if (fstate == 4){
7046 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7047 } else {
7048 throw std::runtime_error("STXS12_ggH_pTH200_300_Nj01 called with invalid argument for final state in fstate_i");
7049 }
7050
7051 if ((this->getModel()).isModelLinearized()) {
7052 return ((myNPbase->STXS12_ggH_pTH200_300_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7053 } else {
7054 return (myNPbase->STXS12_ggH_pTH200_300_Nj01(sqrt_s))*(BrHXXRatio);
7055 }
7056}
7057
7058// -----------------------------------------------------------------------------
7059
7060STXS12_ggH_pTH300_450_Nj01::STXS12_ggH_pTH300_450_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7061: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7062{
7063 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7064 throw std::runtime_error("STXS12_ggH_pTH300_450_Nj01 called with a class whose parent is not NPbase");
7065
7066}
7067
7069{
7070 double BrHXXRatio = 1.0;
7071 if (fstate == 1){
7072 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7073 } else if (fstate == 2){
7074 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7075 } else if (fstate == 3){
7076 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7077 } else if (fstate == 4){
7078 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7079 } else {
7080 throw std::runtime_error("STXS12_ggH_pTH300_450_Nj01 called with invalid argument for final state in fstate_i");
7081 }
7082
7083 if ((this->getModel()).isModelLinearized()) {
7084 return ((myNPbase->STXS12_ggH_pTH300_450_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7085 } else {
7086 return (myNPbase->STXS12_ggH_pTH300_450_Nj01(sqrt_s))*(BrHXXRatio);
7087 }
7088}
7089
7090// -----------------------------------------------------------------------------
7091
7092STXS12_ggH_pTH450_650_Nj01::STXS12_ggH_pTH450_650_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7093: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7094{
7095 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7096 throw std::runtime_error("STXS12_ggH_pTH450_650_Nj01 called with a class whose parent is not NPbase");
7097
7098}
7099
7101{
7102 double BrHXXRatio = 1.0;
7103 if (fstate == 1){
7104 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7105 } else if (fstate == 2){
7106 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7107 } else if (fstate == 3){
7108 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7109 } else if (fstate == 4){
7110 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7111 } else {
7112 throw std::runtime_error("STXS12_ggH_pTH450_650_Nj01 called with invalid argument for final state in fstate_i");
7113 }
7114
7115 if ((this->getModel()).isModelLinearized()) {
7116 return ((myNPbase->STXS12_ggH_pTH450_650_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7117 } else {
7118 return (myNPbase->STXS12_ggH_pTH450_650_Nj01(sqrt_s))*(BrHXXRatio);
7119 }
7120}
7121
7122// -----------------------------------------------------------------------------
7123
7124STXS12_ggH_pTH650_Inf_Nj01::STXS12_ggH_pTH650_Inf_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7125: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7126{
7127 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7128 throw std::runtime_error("STXS12_ggH_pTH650_Inf_Nj01 called with a class whose parent is not NPbase");
7129
7130}
7131
7133{
7134 double BrHXXRatio = 1.0;
7135 if (fstate == 1){
7136 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7137 } else if (fstate == 2){
7138 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7139 } else if (fstate == 3){
7140 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7141 } else if (fstate == 4){
7142 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7143 } else {
7144 throw std::runtime_error("STXS12_ggH_pTH650_Inf_Nj01 called with invalid argument for final state in fstate_i");
7145 }
7146
7147 if ((this->getModel()).isModelLinearized()) {
7148 return ((myNPbase->STXS12_ggH_pTH650_Inf_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7149 } else {
7150 return (myNPbase->STXS12_ggH_pTH650_Inf_Nj01(sqrt_s))*(BrHXXRatio);
7151 }
7152}
7153
7154
7155// -----------------------------------------------------------------------------
7156
7157STXS12_ggH_pTH10_Inf_Nj0::STXS12_ggH_pTH10_Inf_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7158: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7159{
7160 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7161 throw std::runtime_error("STXS12_ggH_pTH10_Inf_Nj0 called with a class whose parent is not NPbase");
7162
7163}
7164
7166{
7167 //-- Production:
7168 double weight = 1.0; //If normalized to the SM
7169
7170 double muProd = myNPbase->STXS12_ggH_pTH10_Inf_Nj0(sqrt_s);
7171 double muProd1 = muProd -1.0;
7172 double muProd2 = 0.0;
7173 //-- Decay:
7174 double BrHXXRatio = 1.0;
7175 double dBrHXXRatio1 = 0.0;
7176 double dBrHXXRatio2 = 0.0;
7177
7178 if (fstate == 1){
7179 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7180 dBrHXXRatio1 = BrHXXRatio - 1.0;
7181 dBrHXXRatio2 = 0.0;
7182 } else if (fstate == 2){
7183 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7184 dBrHXXRatio1 = BrHXXRatio - 1.0;
7185 dBrHXXRatio2 = 0.0;
7186 } else if (fstate == 3){
7187 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7188 dBrHXXRatio1 = BrHXXRatio - 1.0;
7189 dBrHXXRatio2 = 0.0;
7190 } else if (fstate == 4){
7191 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7192 dBrHXXRatio1 = BrHXXRatio - 1.0;
7193 dBrHXXRatio2 = 0.0;
7194 } else {
7195 throw std::runtime_error("STXS12_ggH_pTH10_Inf_Nj0 called with invalid argument for final state in fstate_i");
7196 }
7197
7198 //-- Production x Decay:
7199 if ((this->getModel()).isModelLinearized()){
7200 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7201 } else if((this->getModel()).isModelNPquadratic()){
7202 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7203 } else {
7204 return weight*(muProd)*(BrHXXRatio);
7205 }
7206}
7207
7208
7209
7210
7211
7212// -----------------------------------------------------------------------------
7213
7214//VM:STXS2024;
7215STXS12_ggH_pTH0_10_Nj0::STXS12_ggH_pTH0_10_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7216: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7217{
7218 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7219 throw std::runtime_error("STXS12_ggH_pTH0_10_Nj0 called with a class whose parent is not NPbase");
7220
7221}
7222
7224{
7225 //-- Production:
7226 double weight = 1.0; //If normalized to the SM
7227 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7228 double muProd = myNPbase->STXS12_ggH_pTH0_10_Nj0(sqrt_s);
7229 double muProd1 = muProd -1.0;
7230 double muProd2 = 0.0;
7231
7232 //-- Decay:
7233 double BrHXXRatio = 1.0;
7234 double dBrHXXRatio1 = 0.0;
7235 double dBrHXXRatio2 = 0.0;
7236 if (fstate==0){
7237 // Use for Cross-section [pb] with no Higgs-boson decay
7238 weight = (6.6369); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7239 } else if (fstate == 1){
7240 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7241 dBrHXXRatio1 = BrHXXRatio - 1.0;
7242 dBrHXXRatio2 = 0.0;
7243 } else if (fstate == 2){
7244 BrHXXRatio = (myNPbase->BrHgagaRatio());
7245 dBrHXXRatio1 = BrHXXRatio - 1.0;
7246 dBrHXXRatio2 = 0.0;
7247 } else if (fstate == 3){
7248 BrHXXRatio = (myNPbase->BrHbbRatio());
7249 dBrHXXRatio1 = BrHXXRatio - 1.0;
7250 dBrHXXRatio2 = 0.0;
7251 } else if (fstate == 4){
7252 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7253 dBrHXXRatio1 = BrHXXRatio - 1.0;
7254 dBrHXXRatio2 = 0.0;
7255 } else if (fstate == 5){
7256 BrHXXRatio = (myNPbase->BrHtautauRatio());
7257 dBrHXXRatio1 = BrHXXRatio - 1.0;
7258 dBrHXXRatio2 = 0.0;
7259 } else if (fstate == 6){
7260 BrHXXRatio = (myNPbase->BrHWWRatio());
7261 dBrHXXRatio1 = BrHXXRatio - 1.0;
7262 dBrHXXRatio2 = 0.0;
7263 } else if (fstate == 7){
7264 BrHXXRatio = (myNPbase->BrHZZRatio());
7265 dBrHXXRatio1 = BrHXXRatio - 1.0;
7266 dBrHXXRatio2 = 0.0;
7267 } else {
7268 throw std::runtime_error("STXS12_ggH_pTH0_10_Nj0 called with invalid argument for final state in fstate_i");
7269 }
7270
7271 //-- Production x Decay:
7272 if ((this->getModel()).isModelLinearized()){
7273 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7274 } else if((this->getModel()).isModelNPquadratic()){
7275 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7276 } else {
7277 return weight*(muProd)*(BrHXXRatio);
7278 }
7279
7280}
7281
7282
7283
7284// -----------------------------------------------------------------------------
7285
7286//VM:STXS2024;
7287STXS12_ggH_pTH10_200_Nj0::STXS12_ggH_pTH10_200_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7288: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7289{
7290 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7291 throw std::runtime_error("STXS12_ggH_pTH10_200_Nj0 called with a class whose parent is not NPbase");
7292
7293}
7294
7296{
7297 //-- Production:
7298 double weight = 1.0; //If normalized to the SM
7299 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7300 double muProd = myNPbase->STXS12_ggH_pTH10_200_Nj0(sqrt_s);
7301 double muProd1 = muProd -1.0;
7302 double muProd2 = 0.0;
7303
7304 //-- Decay:
7305 double BrHXXRatio = 1.0;
7306 double dBrHXXRatio1 = 0.0;
7307 double dBrHXXRatio2 = 0.0;
7308 if (fstate==0){
7309 // Use for Cross-section [pb] with no Higgs-boson decay
7310 weight = (20.642); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7311 } else if (fstate == 1){
7312 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7313 dBrHXXRatio1 = BrHXXRatio - 1.0;
7314 dBrHXXRatio2 = 0.0;
7315 } else if (fstate == 2){
7316 BrHXXRatio = (myNPbase->BrHgagaRatio());
7317 dBrHXXRatio1 = BrHXXRatio - 1.0;
7318 dBrHXXRatio2 = 0.0;
7319 } else if (fstate == 3){
7320 BrHXXRatio = (myNPbase->BrHbbRatio());
7321 dBrHXXRatio1 = BrHXXRatio - 1.0;
7322 dBrHXXRatio2 = 0.0;
7323 } else if (fstate == 4){
7324 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7325 dBrHXXRatio1 = BrHXXRatio - 1.0;
7326 dBrHXXRatio2 = 0.0;
7327 } else if (fstate == 5){
7328 BrHXXRatio = (myNPbase->BrHtautauRatio());
7329 dBrHXXRatio1 = BrHXXRatio - 1.0;
7330 dBrHXXRatio2 = 0.0;
7331 } else if (fstate == 6){
7332 BrHXXRatio = (myNPbase->BrHWWRatio());
7333 dBrHXXRatio1 = BrHXXRatio - 1.0;
7334 dBrHXXRatio2 = 0.0;
7335 } else if (fstate == 7){
7336 BrHXXRatio = (myNPbase->BrHZZRatio());
7337 dBrHXXRatio1 = BrHXXRatio - 1.0;
7338 dBrHXXRatio2 = 0.0;
7339 } else {
7340 throw std::runtime_error("STXS12_ggH_pTH10_200_Nj0 called with invalid argument for final state in fstate_i");
7341 }
7342
7343 //-- Production x Decay:
7344 if ((this->getModel()).isModelLinearized()){
7345 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7346 } else if((this->getModel()).isModelNPquadratic()){
7347 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7348 } else {
7349 return weight*(muProd)*(BrHXXRatio);
7350 }
7351
7352}
7353
7354
7355
7356
7357// -----------------------------------------------------------------------------
7358
7359//VM:STXS2024;
7360STXS12_ggH_pTH0_200_Nj0::STXS12_ggH_pTH0_200_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7361: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7362{
7363 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7364 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj0 called with a class whose parent is not NPbase");
7365
7366}
7367
7369{
7370 //-- Production:
7371 double weight = 1.0; //If normalized to the SM
7372 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7373 double muProd = ( 6.6369*(myNPbase->STXS12_ggH_pTH0_10_Nj0(sqrt_s)) +
7375 /(6.6369 + 20.642);
7376 double muProd1 = muProd -1.0;
7377 double muProd2 = 0.0;
7378
7379 //-- Decay:
7380 double BrHXXRatio = 1.0;
7381 double dBrHXXRatio1 = 0.0;
7382 double dBrHXXRatio2 = 0.0;
7383 if (fstate==0){
7384 // Use for Cross-section [pb] with no Higgs-boson decay
7385 weight = (6.6369 + 20.642); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7386 } else if (fstate == 1){
7387 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7388 dBrHXXRatio1 = BrHXXRatio - 1.0;
7389 dBrHXXRatio2 = 0.0;
7390 } else if (fstate == 2){
7391 BrHXXRatio = (myNPbase->BrHgagaRatio());
7392 dBrHXXRatio1 = BrHXXRatio - 1.0;
7393 dBrHXXRatio2 = 0.0;
7394 } else if (fstate == 3){
7395 BrHXXRatio = (myNPbase->BrHbbRatio());
7396 dBrHXXRatio1 = BrHXXRatio - 1.0;
7397 dBrHXXRatio2 = 0.0;
7398 } else if (fstate == 4){
7399 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7400 dBrHXXRatio1 = BrHXXRatio - 1.0;
7401 dBrHXXRatio2 = 0.0;
7402 } else if (fstate == 5){
7403 BrHXXRatio = (myNPbase->BrHtautauRatio());
7404 dBrHXXRatio1 = BrHXXRatio - 1.0;
7405 dBrHXXRatio2 = 0.0;
7406 } else if (fstate == 6){
7407 BrHXXRatio = (myNPbase->BrHWWRatio());
7408 dBrHXXRatio1 = BrHXXRatio - 1.0;
7409 dBrHXXRatio2 = 0.0;
7410 } else if (fstate == 7){
7411 BrHXXRatio = (myNPbase->BrHZZRatio());
7412 dBrHXXRatio1 = BrHXXRatio - 1.0;
7413 dBrHXXRatio2 = 0.0;
7414 } else {
7415 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj0 called with invalid argument for final state in fstate_i");
7416 }
7417
7418 //-- Production x Decay:
7419 if ((this->getModel()).isModelLinearized()){
7420 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7421 } else if((this->getModel()).isModelNPquadratic()){
7422 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7423 } else {
7424 return weight*(muProd)*(BrHXXRatio);
7425 }
7426
7427}
7428
7429
7430
7431
7432// -----------------------------------------------------------------------------
7433
7434//VM:STXS2024;
7435STXS12_ggH_mjj0_350_pTH0_60_Nj1::STXS12_ggH_mjj0_350_pTH0_60_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7436: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7437{
7438 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7439 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj1 called with a class whose parent is not NPbase");
7440
7441}
7442
7444{
7445 //-- Production:
7446 double weight = 1.0; //If normalized to the SM
7447 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7448
7449 double muProd = ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj1(sqrt_s)) );
7450 double muProd1 = muProd -1.0;
7451 double muProd2 = 0.0;
7452
7453 //-- Decay:
7454 double BrHXXRatio = 1.0;
7455 double dBrHXXRatio1 = 0.0;
7456 double dBrHXXRatio2 = 0.0;
7457 if (fstate==0){
7458 // Use for Cross-section [pb] with no Higgs-boson decay
7459 weight = (1.); //NOT in Ref: https://www.hepdata.net/record/ins2104706 Figure7. Missing SM prediction!!!
7460 } else if (fstate == 1){
7461 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7462 dBrHXXRatio1 = BrHXXRatio - 1.0;
7463 dBrHXXRatio2 = 0.0;
7464 } else if (fstate == 2){
7465 BrHXXRatio = (myNPbase->BrHgagaRatio());
7466 dBrHXXRatio1 = BrHXXRatio - 1.0;
7467 dBrHXXRatio2 = 0.0;
7468 } else if (fstate == 3){
7469 BrHXXRatio = (myNPbase->BrHbbRatio());
7470 dBrHXXRatio1 = BrHXXRatio - 1.0;
7471 dBrHXXRatio2 = 0.0;
7472 } else if (fstate == 4){
7473 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7474 dBrHXXRatio1 = BrHXXRatio - 1.0;
7475 dBrHXXRatio2 = 0.0;
7476 } else if (fstate == 5){
7477 BrHXXRatio = (myNPbase->BrHtautauRatio());
7478 dBrHXXRatio1 = BrHXXRatio - 1.0;
7479 dBrHXXRatio2 = 0.0;
7480 } else if (fstate == 6){
7481 BrHXXRatio = (myNPbase->BrHWWRatio());
7482 dBrHXXRatio1 = BrHXXRatio - 1.0;
7483 dBrHXXRatio2 = 0.0;
7484 } else if (fstate == 7){
7485 BrHXXRatio = (myNPbase->BrHZZRatio());
7486 dBrHXXRatio1 = BrHXXRatio - 1.0;
7487 dBrHXXRatio2 = 0.0;
7488 } else {
7489 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj1 called with invalid argument for final state in fstate_i");
7490 }
7491
7492 //-- Production x Decay:
7493 if ((this->getModel()).isModelLinearized()){
7494 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7495 } else if((this->getModel()).isModelNPquadratic()){
7496 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7497 } else {
7498 return weight*(muProd)*(BrHXXRatio);
7499 }
7500
7501}
7502
7503
7504
7505
7506
7507
7508
7509// -----------------------------------------------------------------------------
7510
7511//AG:STXS2024
7512STXS12_ggH_pTH0_60_Nj1::STXS12_ggH_pTH0_60_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7513: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7514{
7515 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7516 throw std::runtime_error("STXS12_ggH_pTH0_60_Nj1 called with a class whose parent is not NPbase");
7517
7518}
7519
7521{
7522 //-- Production:
7523 double weight = 1.0; //If normalized to the SM
7524 double muProd = myNPbase->STXS12_ggH_pTH0_60_Nj1(sqrt_s);
7525 double muProd1 = muProd -1.0;
7526 double muProd2 = 0.0;
7527
7528 //-- Decay:
7529 double BrHXXRatio = 1.0;
7530 double dBrHXXRatio1 = 0.0;
7531 double dBrHXXRatio2 = 0.0;
7532 if (fstate==0){
7533 // Use for Cross-section [pb] with no Higgs-boson decay
7534 weight = 6.50045; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7535 } else if (fstate == 1){
7536 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7537 dBrHXXRatio1 = BrHXXRatio - 1.0;
7538 dBrHXXRatio2 = 0.0;
7539 } else if (fstate == 2){
7540 BrHXXRatio = (myNPbase->BrHgagaRatio());
7541 dBrHXXRatio1 = BrHXXRatio - 1.0;
7542 dBrHXXRatio2 = 0.0;
7543 } else if (fstate == 3){
7544 BrHXXRatio = (myNPbase->BrHbbRatio());
7545 dBrHXXRatio1 = BrHXXRatio - 1.0;
7546 dBrHXXRatio2 = 0.0;
7547 } else if (fstate == 4){
7548 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7549 dBrHXXRatio1 = BrHXXRatio - 1.0;
7550 dBrHXXRatio2 = 0.0;
7551 } else if (fstate == 5){
7552 BrHXXRatio = (myNPbase->BrHtautauRatio());
7553 dBrHXXRatio1 = BrHXXRatio - 1.0;
7554 dBrHXXRatio2 = 0.0;
7555 } else if (fstate == 6){
7556 BrHXXRatio = (myNPbase->BrHWWRatio());
7557 dBrHXXRatio1 = BrHXXRatio - 1.0;
7558 dBrHXXRatio2 = 0.0;
7559 } else if (fstate == 7){
7560 BrHXXRatio = (myNPbase->BrHZZRatio());
7561 dBrHXXRatio1 = BrHXXRatio - 1.0;
7562 dBrHXXRatio2 = 0.0;
7563 } else {
7564 throw std::runtime_error("STXS12_ggH_pTH0_60_Nj1 called with invalid argument for final state in fstate_i");
7565 }
7566
7567 //-- Production x Decay:
7568 if ((this->getModel()).isModelLinearized()){
7569 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7570 } else if((this->getModel()).isModelNPquadratic()){
7571 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7572 } else {
7573 return weight*(muProd)*(BrHXXRatio);
7574 }
7575
7576}
7577
7578// -----------------------------------------------------------------------------
7579
7580//AG:STXS2024
7581STXS12_ggH_pTH60_120_Nj1::STXS12_ggH_pTH60_120_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7582: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7583{
7584 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7585 throw std::runtime_error("STXS12_ggH_pTH60_120_Nj1 called with a class whose parent is not NPbase");
7586
7587}
7588
7590{
7591 //-- Production:
7592 double weight = 1.0; //If normalized to the SM
7593 double muProd = myNPbase->STXS12_ggH_pTH60_120_Nj1(sqrt_s);
7594 double muProd1 = muProd -1.0;
7595 double muProd2 = 0.0;
7596
7597 //-- Decay:
7598 double BrHXXRatio = 1.0;
7599 double dBrHXXRatio1 = 0.0;
7600 double dBrHXXRatio2 = 0.0;
7601 if (fstate==0){
7602 // Use for Cross-section [pb] with no Higgs-boson decay
7603 weight = 4.50294; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7604 } else if (fstate == 1){
7605 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7606 dBrHXXRatio1 = BrHXXRatio - 1.0;
7607 dBrHXXRatio2 = 0.0;
7608 } else if (fstate == 2){
7609 BrHXXRatio = (myNPbase->BrHgagaRatio());
7610 dBrHXXRatio1 = BrHXXRatio - 1.0;
7611 dBrHXXRatio2 = 0.0;
7612 } else if (fstate == 3){
7613 BrHXXRatio = (myNPbase->BrHbbRatio());
7614 dBrHXXRatio1 = BrHXXRatio - 1.0;
7615 dBrHXXRatio2 = 0.0;
7616 } else if (fstate == 4){
7617 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7618 dBrHXXRatio1 = BrHXXRatio - 1.0;
7619 dBrHXXRatio2 = 0.0;
7620 } else if (fstate == 5){
7621 BrHXXRatio = (myNPbase->BrHtautauRatio());
7622 dBrHXXRatio1 = BrHXXRatio - 1.0;
7623 dBrHXXRatio2 = 0.0;
7624 } else if (fstate == 6){
7625 BrHXXRatio = (myNPbase->BrHWWRatio());
7626 dBrHXXRatio1 = BrHXXRatio - 1.0;
7627 dBrHXXRatio2 = 0.0;
7628 } else if (fstate == 7){
7629 BrHXXRatio = (myNPbase->BrHZZRatio());
7630 dBrHXXRatio1 = BrHXXRatio - 1.0;
7631 dBrHXXRatio2 = 0.0;
7632 } else {
7633 throw std::runtime_error("STXS12_ggH_pTH60_120_Nj1 called with invalid argument for final state in fstate_i");
7634 }
7635
7636 //-- Production x Decay:
7637 if ((this->getModel()).isModelLinearized()){
7638 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7639 } else if((this->getModel()).isModelNPquadratic()){
7640 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7641 } else {
7642 return weight*(muProd)*(BrHXXRatio);
7643 }
7644
7645}
7646
7647// -----------------------------------------------------------------------------
7648
7649//AG:STXS2024
7650STXS12_ggH_pTH120_200_Nj1::STXS12_ggH_pTH120_200_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7651: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7652{
7653 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7654 throw std::runtime_error("STXS12_ggH_pTH120_200_Nj1 called with a class whose parent is not NPbase");
7655
7656}
7657
7659{
7660 //-- Production:
7661 double weight = 1.0; //If normalized to the SM
7662 double muProd = myNPbase->STXS12_ggH_pTH120_200_Nj1(sqrt_s);
7663 double muProd1 = muProd -1.0;
7664 double muProd2 = 0.0;
7665
7666 //-- Decay:
7667 double BrHXXRatio = 1.0;
7668 double dBrHXXRatio1 = 0.0;
7669 double dBrHXXRatio2 = 0.0;
7670 if (fstate==0){
7671 // Use for Cross-section [pb] with no Higgs-boson decay
7672 weight = 0.74712; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7673 } else if (fstate == 1){
7674 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7675 dBrHXXRatio1 = BrHXXRatio - 1.0;
7676 dBrHXXRatio2 = 0.0;
7677 } else if (fstate == 2){
7678 BrHXXRatio = (myNPbase->BrHgagaRatio());
7679 dBrHXXRatio1 = BrHXXRatio - 1.0;
7680 dBrHXXRatio2 = 0.0;
7681 } else if (fstate == 3){
7682 BrHXXRatio = (myNPbase->BrHbbRatio());
7683 dBrHXXRatio1 = BrHXXRatio - 1.0;
7684 dBrHXXRatio2 = 0.0;
7685 } else if (fstate == 4){
7686 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7687 dBrHXXRatio1 = BrHXXRatio - 1.0;
7688 dBrHXXRatio2 = 0.0;
7689 } else if (fstate == 5){
7690 BrHXXRatio = (myNPbase->BrHtautauRatio());
7691 dBrHXXRatio1 = BrHXXRatio - 1.0;
7692 dBrHXXRatio2 = 0.0;
7693 } else if (fstate == 6){
7694 BrHXXRatio = (myNPbase->BrHWWRatio());
7695 dBrHXXRatio1 = BrHXXRatio - 1.0;
7696 dBrHXXRatio2 = 0.0;
7697 } else if (fstate == 7){
7698 BrHXXRatio = (myNPbase->BrHZZRatio());
7699 dBrHXXRatio1 = BrHXXRatio - 1.0;
7700 dBrHXXRatio2 = 0.0;
7701 } else {
7702 throw std::runtime_error("STXS12_ggH_pTH120_200_Nj1 called with invalid argument for final state in fstate_i");
7703 }
7704
7705 //-- Production x Decay:
7706 if ((this->getModel()).isModelLinearized()){
7707 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7708 } else if((this->getModel()).isModelNPquadratic()){
7709 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7710 } else {
7711 return weight*(muProd)*(BrHXXRatio);
7712 }
7713
7714}
7715
7716// -----------------------------------------------------------------------------
7717
7718STXS12_ggH_mjj0_350_pTH0_60_Nj2::STXS12_ggH_mjj0_350_pTH0_60_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7719: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7720{
7721 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7722 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj2 called with a class whose parent is not NPbase");
7723
7724}
7725
7727{
7728 double BrHXXRatio = 1.0;
7729 if (fstate == 1){
7730 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7731 } else if (fstate == 2){
7732 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7733 } else if (fstate == 3){
7734 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7735 } else if (fstate == 4){
7736 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7737 } else {
7738 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj2 called with invalid argument for final state in fstate_i");
7739 }
7740
7741 if ((this->getModel()).isModelLinearized()) {
7742 return ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7743 } else {
7744 return (myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s))*(BrHXXRatio);
7745 }
7746}
7747
7748// -----------------------------------------------------------------------------
7749
7750STXS12_ggH_mjj0_350_pTH60_120_Nj2::STXS12_ggH_mjj0_350_pTH60_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7751: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7752{
7753 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7754 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH60_120_Nj2 called with a class whose parent is not NPbase");
7755
7756}
7757
7759{
7760 double BrHXXRatio = 1.0;
7761 if (fstate == 1){
7762 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7763 } else if (fstate == 2){
7764 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7765 } else if (fstate == 3){
7766 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7767 } else if (fstate == 4){
7768 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7769 } else {
7770 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH60_120_Nj2 called with invalid argument for final state in fstate_i");
7771 }
7772
7773 if ((this->getModel()).isModelLinearized()) {
7774 return ((myNPbase->STXS12_ggH_mjj0_350_pTH60_120_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7775 } else {
7776 return (myNPbase->STXS12_ggH_mjj0_350_pTH60_120_Nj2(sqrt_s))*(BrHXXRatio);
7777 }
7778}
7779
7780
7781
7782
7783
7784// -----------------------------------------------------------------------------
7785
7786//VM:STXS2024;
7787STXS12_ggH_mjj0_350_pTH0_120_Nj2::STXS12_ggH_mjj0_350_pTH0_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7788: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7789{
7790 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7791 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj2 called with a class whose parent is not NPbase");
7792
7793}
7794
7796{
7797 //-- Production:
7798 double weight = 1.0; //If normalized to the SM
7799 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7800 //We should weight each xsection with the SM prediction. We need to check
7801 //this values, nevertheless, the difference between the two parametrisations
7802 //is extremely small (way beyond our current precision)
7803 double muProd = ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s)) +
7805 /(2.);
7806 double muProd1 = muProd -1.0;
7807 double muProd2 = 0.0;
7808
7809 //-- Decay:
7810 double BrHXXRatio = 1.0;
7811 double dBrHXXRatio1 = 0.0;
7812 double dBrHXXRatio2 = 0.0;
7813 if (fstate==0){
7814 // Use for Cross-section [pb] with no Higgs-boson decay
7815 weight = (2.9636); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7816 } else if (fstate == 1){
7817 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7818 dBrHXXRatio1 = BrHXXRatio - 1.0;
7819 dBrHXXRatio2 = 0.0;
7820 } else if (fstate == 2){
7821 BrHXXRatio = (myNPbase->BrHgagaRatio());
7822 dBrHXXRatio1 = BrHXXRatio - 1.0;
7823 dBrHXXRatio2 = 0.0;
7824 } else if (fstate == 3){
7825 BrHXXRatio = (myNPbase->BrHbbRatio());
7826 dBrHXXRatio1 = BrHXXRatio - 1.0;
7827 dBrHXXRatio2 = 0.0;
7828 } else if (fstate == 4){
7829 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7830 dBrHXXRatio1 = BrHXXRatio - 1.0;
7831 dBrHXXRatio2 = 0.0;
7832 } else if (fstate == 5){
7833 BrHXXRatio = (myNPbase->BrHtautauRatio());
7834 dBrHXXRatio1 = BrHXXRatio - 1.0;
7835 dBrHXXRatio2 = 0.0;
7836 } else if (fstate == 6){
7837 BrHXXRatio = (myNPbase->BrHWWRatio());
7838 dBrHXXRatio1 = BrHXXRatio - 1.0;
7839 dBrHXXRatio2 = 0.0;
7840 } else if (fstate == 7){
7841 BrHXXRatio = (myNPbase->BrHZZRatio());
7842 dBrHXXRatio1 = BrHXXRatio - 1.0;
7843 dBrHXXRatio2 = 0.0;
7844 } else {
7845 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj2 called with invalid argument for final state in fstate_i");
7846 }
7847
7848 //-- Production x Decay:
7849 if ((this->getModel()).isModelLinearized()){
7850 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7851 } else if((this->getModel()).isModelNPquadratic()){
7852 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7853 } else {
7854 return weight*(muProd)*(BrHXXRatio);
7855 }
7856
7857}
7858
7859
7860
7861
7862// -----------------------------------------------------------------------------
7863
7864//AG:STXS2024
7865STXS12_ggH_mjj0_350_pTH120_200_Nj2::STXS12_ggH_mjj0_350_pTH120_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7866: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7867{
7868 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7869 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH120_200_Nj2 called with a class whose parent is not NPbase");
7870
7871}
7872
7874{
7875 //-- Production:
7876 double weight = 1.0; //If normalized to the SM
7878 double muProd1 = muProd -1.0;
7879 double muProd2 = 0.0;
7880
7881 //-- Decay:
7882 double BrHXXRatio = 1.0;
7883 double dBrHXXRatio1 = 0.0;
7884 double dBrHXXRatio2 = 0.0;
7885 if (fstate==0){
7886 // Use for Cross-section [pb] with no Higgs-boson decay
7887 weight = 0.94325; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7888 } else if (fstate == 1){
7889 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7890 dBrHXXRatio1 = BrHXXRatio - 1.0;
7891 dBrHXXRatio2 = 0.0;
7892 } else if (fstate == 2){
7893 BrHXXRatio = (myNPbase->BrHgagaRatio());
7894 dBrHXXRatio1 = BrHXXRatio - 1.0;
7895 dBrHXXRatio2 = 0.0;
7896 } else if (fstate == 3){
7897 BrHXXRatio = (myNPbase->BrHbbRatio());
7898 dBrHXXRatio1 = BrHXXRatio - 1.0;
7899 dBrHXXRatio2 = 0.0;
7900 } else if (fstate == 4){
7901 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7902 dBrHXXRatio1 = BrHXXRatio - 1.0;
7903 dBrHXXRatio2 = 0.0;
7904 } else if (fstate == 5){
7905 BrHXXRatio = (myNPbase->BrHtautauRatio());
7906 dBrHXXRatio1 = BrHXXRatio - 1.0;
7907 dBrHXXRatio2 = 0.0;
7908 }else {
7909 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH120_200_Nj2 called with invalid argument for final state in fstate_i");
7910 }
7911
7912 //-- Production x Decay:
7913 if ((this->getModel()).isModelLinearized()){
7914 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7915 } else if((this->getModel()).isModelNPquadratic()){
7916 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7917 } else {
7918 return weight*(muProd)*(BrHXXRatio);
7919 }
7920
7921}
7922
7923
7924
7925
7926//VM:STXS2024;
7927STXS12_ggH_mjj350_Inf_pTH0_200_Nj2::STXS12_ggH_mjj350_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7928: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7929{
7930 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7931 throw std::runtime_error("STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
7932
7933}
7934
7936{
7937 //-- Production:
7938 double weight = 1.0; //If normalized to the SM
7939 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7940 //We should weight each xsection with the SM prediction. We need to check
7941 //this values, nevertheless, the difference between the two parametrisations
7942 //is extremely small (way beyond our current precision)
7945 /(2.);
7946 double muProd1 = muProd -1.0;
7947 double muProd2 = 0.0;
7948
7949 //-- Decay:
7950 double BrHXXRatio = 1.0;
7951 double dBrHXXRatio1 = 0.0;
7952 double dBrHXXRatio2 = 0.0;
7953 if (fstate==0){
7954 // Use for Cross-section [pb] with no Higgs-boson decay
7955 weight = (0.92136); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7956 } else if (fstate == 1){
7957 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7958 dBrHXXRatio1 = BrHXXRatio - 1.0;
7959 dBrHXXRatio2 = 0.0;
7960 } else if (fstate == 2){
7961 BrHXXRatio = (myNPbase->BrHgagaRatio());
7962 dBrHXXRatio1 = BrHXXRatio - 1.0;
7963 dBrHXXRatio2 = 0.0;
7964 } else if (fstate == 3){
7965 BrHXXRatio = (myNPbase->BrHbbRatio());
7966 dBrHXXRatio1 = BrHXXRatio - 1.0;
7967 dBrHXXRatio2 = 0.0;
7968 } else if (fstate == 4){
7969 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7970 dBrHXXRatio1 = BrHXXRatio - 1.0;
7971 dBrHXXRatio2 = 0.0;
7972 } else if (fstate == 5){
7973 BrHXXRatio = (myNPbase->BrHtautauRatio());
7974 dBrHXXRatio1 = BrHXXRatio - 1.0;
7975 dBrHXXRatio2 = 0.0;
7976 } else if (fstate == 6){
7977 BrHXXRatio = (myNPbase->BrHWWRatio());
7978 dBrHXXRatio1 = BrHXXRatio - 1.0;
7979 dBrHXXRatio2 = 0.0;
7980 } else if (fstate == 7){
7981 BrHXXRatio = (myNPbase->BrHZZRatio());
7982 dBrHXXRatio1 = BrHXXRatio - 1.0;
7983 dBrHXXRatio2 = 0.0;
7984 } else {
7985 throw std::runtime_error("STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
7986 }
7987
7988 //-- Production x Decay:
7989 if ((this->getModel()).isModelLinearized()){
7990 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7991 } else if((this->getModel()).isModelNPquadratic()){
7992 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7993 } else {
7994 return weight*(muProd)*(BrHXXRatio);
7995 }
7996
7997}
7998
7999
8000// -----------------------------------------------------------------------------
8001
8003: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8004{
8005 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8006 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 called with a class whose parent is not NPbase");
8007
8008}
8009
8011{
8012 double BrHXXRatio = 1.0;
8013 if (fstate == 1){
8014 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8015 } else if (fstate == 2){
8016 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8017 } else if (fstate == 3){
8018 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8019 } else if (fstate == 4){
8020 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8021 } else {
8022 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
8023 }
8024
8025 if ((this->getModel()).isModelLinearized()) {
8026 return ((myNPbase->STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8027 } else {
8029 }
8030}
8031
8032// -----------------------------------------------------------------------------
8033
8035: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8036{
8037
8038 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8039 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
8040
8041}
8042
8044{
8045 double BrHXXRatio = 1.0;
8046 if (fstate == 1){
8047 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8048 } else if (fstate == 2){
8049 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8050 } else if (fstate == 3){
8051 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8052 } else if (fstate == 4){
8053 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8054 } else {
8055 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
8056 }
8057
8058 if ((this->getModel()).isModelLinearized()) {
8059 return ((myNPbase->STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8060 } else {
8062 }
8063}
8064
8065// -----------------------------------------------------------------------------
8066
8068: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8069{
8070 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8071 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 called with a class whose parent is not NPbase");
8072
8073}
8074
8076{
8077 double BrHXXRatio = 1.0;
8078 if (fstate == 1){
8079 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8080 } else if (fstate == 2){
8081 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8082 } else if (fstate == 3){
8083 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8084 } else if (fstate == 4){
8085 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8086 } else {
8087 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
8088 }
8089
8090 if ((this->getModel()).isModelLinearized()) {
8091 return ((myNPbase->STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8092 } else {
8094 }
8095}
8096
8097// -----------------------------------------------------------------------------
8098
8100: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8101{
8102 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8103 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
8104
8105}
8106
8108{
8109 double BrHXXRatio = 1.0;
8110 if (fstate == 1){
8111 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8112 } else if (fstate == 2){
8113 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8114 } else if (fstate == 3){
8115 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8116 } else if (fstate == 4){
8117 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8118 } else {
8119 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
8120 }
8121
8122 if ((this->getModel()).isModelLinearized()) {
8123 return ((myNPbase->STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8124 } else {
8126 }
8127}
8128
8129
8130
8131
8132
8133// -----------------------------------------------------------------------------
8134
8135//VM:STXS2024;
8136STXS12_ggH_pTH0_200_Nj2::STXS12_ggH_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8137: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8138{
8139 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8140 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj2 called with a class whose parent is not NPbase");
8141
8142}
8143
8145{
8146
8147
8148
8149 //-- Production:
8150 double weight = 1.0; //If normalized to the SM
8151 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8152 //VM: In the reference above we have the SM predictions for less bins. Angelica should have
8153 //the ones for Madgraph and we could use those. In any case the parametrisation is very stable
8154 //we give the same weight to the bins for which we don't have the SM prediction (for the moment)!
8155 //The possible error that we could be introducing here is way below our precision!
8156 double muProd = (
8160 )/(2.9636+0.94321+0.87751);
8161 double muProd1 = muProd -1.0;
8162 double muProd2 = 0.0;
8163
8164 //-- Decay:
8165 double BrHXXRatio = 1.0;
8166 double dBrHXXRatio1 = 0.0;
8167 double dBrHXXRatio2 = 0.0;
8168 if (fstate==0){
8169 // Use for Cross-section [pb] with no Higgs-boson decay
8170 weight = (2.9636+0.94321+0.87751); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8171 } else if (fstate == 1){
8172 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8173 dBrHXXRatio1 = BrHXXRatio - 1.0;
8174 dBrHXXRatio2 = 0.0;
8175 } else if (fstate == 2){
8176 BrHXXRatio = (myNPbase->BrHgagaRatio());
8177 dBrHXXRatio1 = BrHXXRatio - 1.0;
8178 dBrHXXRatio2 = 0.0;
8179 } else if (fstate == 3){
8180 BrHXXRatio = (myNPbase->BrHbbRatio());
8181 dBrHXXRatio1 = BrHXXRatio - 1.0;
8182 dBrHXXRatio2 = 0.0;
8183 } else if (fstate == 4){
8184 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8185 dBrHXXRatio1 = BrHXXRatio - 1.0;
8186 dBrHXXRatio2 = 0.0;
8187 } else if (fstate == 5){
8188 BrHXXRatio = (myNPbase->BrHtautauRatio());
8189 dBrHXXRatio1 = BrHXXRatio - 1.0;
8190 dBrHXXRatio2 = 0.0;
8191 } else if (fstate == 6){
8192 BrHXXRatio = (myNPbase->BrHWWRatio());
8193 dBrHXXRatio1 = BrHXXRatio - 1.0;
8194 dBrHXXRatio2 = 0.0;
8195 } else if (fstate == 7){
8196 BrHXXRatio = (myNPbase->BrHZZRatio());
8197 dBrHXXRatio1 = BrHXXRatio - 1.0;
8198 dBrHXXRatio2 = 0.0;
8199 } else {
8200 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
8201 }
8202
8203 //-- Production x Decay:
8204 if ((this->getModel()).isModelLinearized()){
8205 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8206 } else if((this->getModel()).isModelNPquadratic()){
8207 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8208 } else {
8209 return weight*(muProd)*(BrHXXRatio);
8210 }
8211
8212}
8213
8214
8215
8216
8217
8218
8219
8220// -----------------------------------------------------------------------------
8221
8222
8223//VM:STXS2024;
8224STXS12_ggH_pTH200_Inf::STXS12_ggH_pTH200_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8225: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8226{
8227 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8228 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with a class whose parent is not NPbase");
8229
8230}
8231
8233{
8234 //-- Production:
8235 double weight = 1.0; //If normalized to the SM
8236 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8237 double muProd = ( 0.45825*(myNPbase->STXS12_ggH_pTH200_300(sqrt_s)) +
8240 /(0.45825 + 0.10632 + 0.017974);
8241 double muProd1 = muProd -1.0;
8242 double muProd2 = 0.0;
8243
8244 //-- Decay:
8245 double BrHXXRatio = 1.0;
8246 double dBrHXXRatio1 = 0.0;
8247 double dBrHXXRatio2 = 0.0;
8248 if (fstate==0){
8249 // Use for Cross-section [pb] with no Higgs-boson decay
8250 weight = (0.45825 + 0.10632 + 0.017974); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8251 } else if (fstate == 1){
8252 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8253 dBrHXXRatio1 = BrHXXRatio - 1.0;
8254 dBrHXXRatio2 = 0.0;
8255 } else if (fstate == 2){
8256 BrHXXRatio = (myNPbase->BrHgagaRatio());
8257 dBrHXXRatio1 = BrHXXRatio - 1.0;
8258 dBrHXXRatio2 = 0.0;
8259 } else if (fstate == 3){
8260 BrHXXRatio = (myNPbase->BrHbbRatio());
8261 dBrHXXRatio1 = BrHXXRatio - 1.0;
8262 dBrHXXRatio2 = 0.0;
8263 } else if (fstate == 4){
8264 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8265 dBrHXXRatio1 = BrHXXRatio - 1.0;
8266 dBrHXXRatio2 = 0.0;
8267 } else if (fstate == 5){
8268 BrHXXRatio = (myNPbase->BrHtautauRatio());
8269 dBrHXXRatio1 = BrHXXRatio - 1.0;
8270 dBrHXXRatio2 = 0.0;
8271 } else if (fstate == 6){
8272 BrHXXRatio = (myNPbase->BrHWWRatio());
8273 dBrHXXRatio1 = BrHXXRatio - 1.0;
8274 dBrHXXRatio2 = 0.0;
8275 } else if (fstate == 7){
8276 BrHXXRatio = (myNPbase->BrHZZRatio());
8277 dBrHXXRatio1 = BrHXXRatio - 1.0;
8278 dBrHXXRatio2 = 0.0;
8279 } else {
8280 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with invalid argument for final state in fstate_i");
8281 }
8282
8283 //-- Production x Decay:
8284 if ((this->getModel()).isModelLinearized()){
8285 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8286 } else if((this->getModel()).isModelNPquadratic()){
8287 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8288 } else {
8289 return weight*(muProd)*(BrHXXRatio);
8290 }
8291
8292}
8293
8294
8295
8296
8297// -----------------------------------------------------------------------------
8298
8299
8300//VM:STXS2024;
8301STXS12_ggH_pTH300_Inf::STXS12_ggH_pTH300_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8302: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8303{
8304 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8305 throw std::runtime_error("STXS12_ggH_pTH300_Inf called with a class whose parent is not NPbase");
8306
8307}
8308
8310{
8311 //-- Production:
8312 double weight = 1.0; //If normalized to the SM
8313 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8314 double muProd = (0.10632*(myNPbase->STXS12_ggH_pTH300_450(sqrt_s)) +
8316 /(0.10632 + 0.017974);
8317 double muProd1 = muProd -1.0;
8318 double muProd2 = 0.0;
8319
8320 //-- Decay:
8321 double BrHXXRatio = 1.0;
8322 double dBrHXXRatio1 = 0.0;
8323 double dBrHXXRatio2 = 0.0;
8324 if (fstate==0){
8325 // Use for Cross-section [pb] with no Higgs-boson decay
8326 weight = (0.10632 + 0.017974); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8327 } else if (fstate == 1){
8328 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8329 dBrHXXRatio1 = BrHXXRatio - 1.0;
8330 dBrHXXRatio2 = 0.0;
8331 } else if (fstate == 2){
8332 BrHXXRatio = (myNPbase->BrHgagaRatio());
8333 dBrHXXRatio1 = BrHXXRatio - 1.0;
8334 dBrHXXRatio2 = 0.0;
8335 } else if (fstate == 3){
8336 BrHXXRatio = (myNPbase->BrHbbRatio());
8337 dBrHXXRatio1 = BrHXXRatio - 1.0;
8338 dBrHXXRatio2 = 0.0;
8339 } else if (fstate == 4){
8340 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8341 dBrHXXRatio1 = BrHXXRatio - 1.0;
8342 dBrHXXRatio2 = 0.0;
8343 } else if (fstate == 5){
8344 BrHXXRatio = (myNPbase->BrHtautauRatio());
8345 dBrHXXRatio1 = BrHXXRatio - 1.0;
8346 dBrHXXRatio2 = 0.0;
8347 } else if (fstate == 6){
8348 BrHXXRatio = (myNPbase->BrHWWRatio());
8349 dBrHXXRatio1 = BrHXXRatio - 1.0;
8350 dBrHXXRatio2 = 0.0;
8351 } else if (fstate == 7){
8352 BrHXXRatio = (myNPbase->BrHZZRatio());
8353 dBrHXXRatio1 = BrHXXRatio - 1.0;
8354 dBrHXXRatio2 = 0.0;
8355 } else {
8356 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with invalid argument for final state in fstate_i");
8357 }
8358
8359 //-- Production x Decay:
8360 if ((this->getModel()).isModelLinearized()){
8361 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8362 } else if((this->getModel()).isModelNPquadratic()){
8363 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8364 } else {
8365 return weight*(muProd)*(BrHXXRatio);
8366 }
8367
8368}
8369
8370
8371// -----------------------------------------------------------------------------
8372
8373
8374//VM:STXS2024;
8375STXS12_ggH_pTH200_300::STXS12_ggH_pTH200_300(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8376: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8377{
8378 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8379 throw std::runtime_error("STXS12_ggH_pTH200_300 called with a class whose parent is not NPbase");
8380
8381}
8382
8384{
8385 //-- Production:
8386 double weight = 1.0; //If normalized to the SM
8387 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8388 double muProd = myNPbase->STXS12_ggH_pTH200_300(sqrt_s);
8389 double muProd1 = muProd -1.0;
8390 double muProd2 = 0.0;
8391
8392 //-- Decay:
8393 double BrHXXRatio = 1.0;
8394 double dBrHXXRatio1 = 0.0;
8395 double dBrHXXRatio2 = 0.0;
8396 if (fstate==0){
8397 // Use for Cross-section [pb] with no Higgs-boson decay
8398 weight = (0.45825 ); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8399 } else if (fstate == 1){
8400 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8401 dBrHXXRatio1 = BrHXXRatio - 1.0;
8402 dBrHXXRatio2 = 0.0;
8403 } else if (fstate == 2){
8404 BrHXXRatio = (myNPbase->BrHgagaRatio());
8405 dBrHXXRatio1 = BrHXXRatio - 1.0;
8406 dBrHXXRatio2 = 0.0;
8407 } else if (fstate == 3){
8408 BrHXXRatio = (myNPbase->BrHbbRatio());
8409 dBrHXXRatio1 = BrHXXRatio - 1.0;
8410 dBrHXXRatio2 = 0.0;
8411 } else if (fstate == 4){
8412 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8413 dBrHXXRatio1 = BrHXXRatio - 1.0;
8414 dBrHXXRatio2 = 0.0;
8415 } else if (fstate == 5){
8416 BrHXXRatio = (myNPbase->BrHtautauRatio());
8417 dBrHXXRatio1 = BrHXXRatio - 1.0;
8418 dBrHXXRatio2 = 0.0;
8419 } else if (fstate == 6){
8420 BrHXXRatio = (myNPbase->BrHWWRatio());
8421 dBrHXXRatio1 = BrHXXRatio - 1.0;
8422 dBrHXXRatio2 = 0.0;
8423 } else if (fstate == 7){
8424 BrHXXRatio = (myNPbase->BrHZZRatio());
8425 dBrHXXRatio1 = BrHXXRatio - 1.0;
8426 dBrHXXRatio2 = 0.0;
8427 } else {
8428 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
8429 }
8430
8431 //-- Production x Decay:
8432 if ((this->getModel()).isModelLinearized()){
8433 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8434 } else if((this->getModel()).isModelNPquadratic()){
8435 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8436 } else {
8437 return weight*(muProd)*(BrHXXRatio);
8438 }
8439
8440}
8441
8442
8443
8444// -----------------------------------------------------------------------------
8445
8446
8447//VM:STXS2024;
8448STXS12_ggH_pTH300_450::STXS12_ggH_pTH300_450(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8449: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8450{
8451 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8452 throw std::runtime_error("STXS12_ggH_pTH300_450 called with a class whose parent is not NPbase");
8453
8454}
8455
8457{
8458 //-- Production:
8459 double weight = 1.0; //If normalized to the SM
8460 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8461 double muProd = myNPbase->STXS12_ggH_pTH300_450(sqrt_s);
8462 double muProd1 = muProd -1.0;
8463 double muProd2 = 0.0;
8464
8465 //-- Decay:
8466 double BrHXXRatio = 1.0;
8467 double dBrHXXRatio1 = 0.0;
8468 double dBrHXXRatio2 = 0.0;
8469 if (fstate==0){
8470 // Use for Cross-section [pb] with no Higgs-boson decay
8471 weight = 0.10632; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8472 } else if (fstate == 1){
8473 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8474 dBrHXXRatio1 = BrHXXRatio - 1.0;
8475 dBrHXXRatio2 = 0.0;
8476 } else if (fstate == 2){
8477 BrHXXRatio = (myNPbase->BrHgagaRatio());
8478 dBrHXXRatio1 = BrHXXRatio - 1.0;
8479 dBrHXXRatio2 = 0.0;
8480 } else if (fstate == 3){
8481 BrHXXRatio = (myNPbase->BrHbbRatio());
8482 dBrHXXRatio1 = BrHXXRatio - 1.0;
8483 dBrHXXRatio2 = 0.0;
8484 } else if (fstate == 4){
8485 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8486 dBrHXXRatio1 = BrHXXRatio - 1.0;
8487 dBrHXXRatio2 = 0.0;
8488 } else if (fstate == 5){
8489 BrHXXRatio = (myNPbase->BrHtautauRatio());
8490 dBrHXXRatio1 = BrHXXRatio - 1.0;
8491 dBrHXXRatio2 = 0.0;
8492 } else if (fstate == 6){
8493 BrHXXRatio = (myNPbase->BrHWWRatio());
8494 dBrHXXRatio1 = BrHXXRatio - 1.0;
8495 dBrHXXRatio2 = 0.0;
8496 } else if (fstate == 7){
8497 BrHXXRatio = (myNPbase->BrHZZRatio());
8498 dBrHXXRatio1 = BrHXXRatio - 1.0;
8499 dBrHXXRatio2 = 0.0;
8500 } else {
8501 throw std::runtime_error("STXS12_ggH_pTH300_450 called with invalid argument for final state in fstate_i");
8502 }
8503
8504 //-- Production x Decay:
8505 if ((this->getModel()).isModelLinearized()){
8506 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8507 } else if((this->getModel()).isModelNPquadratic()){
8508 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8509 } else {
8510 return weight*(muProd)*(BrHXXRatio);
8511 }
8512
8513}
8514
8515
8516
8517
8518// -----------------------------------------------------------------------------
8519
8520
8521//VM:STXS2024;
8522STXS12_ggH_pTH450_650::STXS12_ggH_pTH450_650(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8523: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8524{
8525 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8526 throw std::runtime_error("STXS12_ggH_pTH450_650 called with a class whose parent is not NPbase");
8527
8528}
8529
8531{
8532 //-- Production:
8533 double weight = 1.0; //If normalized to the SM
8534 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8535 double muProd = myNPbase->STXS12_ggH_pTH450_650(sqrt_s);
8536 double muProd1 = muProd -1.0;
8537 double muProd2 = 0.0;
8538
8539 //-- Decay:
8540 double BrHXXRatio = 1.0;
8541 double dBrHXXRatio1 = 0.0;
8542 double dBrHXXRatio2 = 0.0;
8543 if (fstate==0){
8544 // Use for Cross-section [pb] with no Higgs-boson decay
8545 weight = 1.; //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8546 } else if (fstate == 1){
8547 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8548 dBrHXXRatio1 = BrHXXRatio - 1.0;
8549 dBrHXXRatio2 = 0.0;
8550 } else if (fstate == 2){
8551 BrHXXRatio = (myNPbase->BrHgagaRatio());
8552 dBrHXXRatio1 = BrHXXRatio - 1.0;
8553 dBrHXXRatio2 = 0.0;
8554 } else if (fstate == 3){
8555 BrHXXRatio = (myNPbase->BrHbbRatio());
8556 dBrHXXRatio1 = BrHXXRatio - 1.0;
8557 dBrHXXRatio2 = 0.0;
8558 } else if (fstate == 4){
8559 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8560 dBrHXXRatio1 = BrHXXRatio - 1.0;
8561 dBrHXXRatio2 = 0.0;
8562 } else if (fstate == 5){
8563 BrHXXRatio = (myNPbase->BrHtautauRatio());
8564 dBrHXXRatio1 = BrHXXRatio - 1.0;
8565 dBrHXXRatio2 = 0.0;
8566 } else if (fstate == 6){
8567 BrHXXRatio = (myNPbase->BrHWWRatio());
8568 dBrHXXRatio1 = BrHXXRatio - 1.0;
8569 dBrHXXRatio2 = 0.0;
8570 } else if (fstate == 7){
8571 BrHXXRatio = (myNPbase->BrHZZRatio());
8572 dBrHXXRatio1 = BrHXXRatio - 1.0;
8573 dBrHXXRatio2 = 0.0;
8574 } else {
8575 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8576 }
8577
8578 //-- Production x Decay:
8579 if ((this->getModel()).isModelLinearized()){
8580 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8581 } else if((this->getModel()).isModelNPquadratic()){
8582 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8583 } else {
8584 return weight*(muProd)*(BrHXXRatio);
8585 }
8586
8587}
8588
8589
8590
8591// -----------------------------------------------------------------------------
8592
8593
8594//VM:STXS2024;
8595STXS12_ggH_pTH650_Inf::STXS12_ggH_pTH650_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8596: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8597{
8598 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8599 throw std::runtime_error("STXS12_ggH_pTH650_Inf called with a class whose parent is not NPbase");
8600
8601}
8602
8604{
8605 //-- Production:
8606 double weight = 1.0; //If normalized to the SM
8607 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8608 double muProd = myNPbase->STXS12_ggH_pTH650_Inf(sqrt_s);
8609 double muProd1 = muProd -1.0;
8610 double muProd2 = 0.0;
8611
8612 //-- Decay:
8613 double BrHXXRatio = 1.0;
8614 double dBrHXXRatio1 = 0.0;
8615 double dBrHXXRatio2 = 0.0;
8616 if (fstate==0){
8617 // Use for Cross-section [pb] with no Higgs-boson decay
8618 weight = 1.; //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8619 } else if (fstate == 1){
8620 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8621 dBrHXXRatio1 = BrHXXRatio - 1.0;
8622 dBrHXXRatio2 = 0.0;
8623 } else if (fstate == 2){
8624 BrHXXRatio = (myNPbase->BrHgagaRatio());
8625 dBrHXXRatio1 = BrHXXRatio - 1.0;
8626 dBrHXXRatio2 = 0.0;
8627 } else if (fstate == 3){
8628 BrHXXRatio = (myNPbase->BrHbbRatio());
8629 dBrHXXRatio1 = BrHXXRatio - 1.0;
8630 dBrHXXRatio2 = 0.0;
8631 } else if (fstate == 4){
8632 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8633 dBrHXXRatio1 = BrHXXRatio - 1.0;
8634 dBrHXXRatio2 = 0.0;
8635 } else if (fstate == 5){
8636 BrHXXRatio = (myNPbase->BrHtautauRatio());
8637 dBrHXXRatio1 = BrHXXRatio - 1.0;
8638 dBrHXXRatio2 = 0.0;
8639 } else if (fstate == 6){
8640 BrHXXRatio = (myNPbase->BrHWWRatio());
8641 dBrHXXRatio1 = BrHXXRatio - 1.0;
8642 dBrHXXRatio2 = 0.0;
8643 } else if (fstate == 7){
8644 BrHXXRatio = (myNPbase->BrHZZRatio());
8645 dBrHXXRatio1 = BrHXXRatio - 1.0;
8646 dBrHXXRatio2 = 0.0;
8647 } else {
8648 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8649 }
8650
8651 //-- Production x Decay:
8652 if ((this->getModel()).isModelLinearized()){
8653 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8654 } else if((this->getModel()).isModelNPquadratic()){
8655 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8656 } else {
8657 return weight*(muProd)*(BrHXXRatio);
8658 }
8659
8660}
8661
8662
8663
8664// -----------------------------------------------------------------------------
8665
8666
8667//VM:STXS2024;
8668STXS12_ggH_pTH450_Inf::STXS12_ggH_pTH450_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8669: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8670{
8671 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8672 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with a class whose parent is not NPbase");
8673
8674}
8675
8677{
8678 //-- Production:
8679 double weight = 1.0; //If normalized to the SM
8680 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8681 double muProd = myNPbase->STXS12_ggH_pTH450_Inf(sqrt_s);
8682 double muProd1 = muProd -1.0;
8683 double muProd2 = 0.0;
8684
8685 //-- Decay:
8686 double BrHXXRatio = 1.0;
8687 double dBrHXXRatio1 = 0.0;
8688 double dBrHXXRatio2 = 0.0;
8689 if (fstate==0){
8690 // Use for Cross-section [pb] with no Higgs-boson decay
8691 weight = 0.017974; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8692 } else if (fstate == 1){
8693 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8694 dBrHXXRatio1 = BrHXXRatio - 1.0;
8695 dBrHXXRatio2 = 0.0;
8696 } else if (fstate == 2){
8697 BrHXXRatio = (myNPbase->BrHgagaRatio());
8698 dBrHXXRatio1 = BrHXXRatio - 1.0;
8699 dBrHXXRatio2 = 0.0;
8700 } else if (fstate == 3){
8701 BrHXXRatio = (myNPbase->BrHbbRatio());
8702 dBrHXXRatio1 = BrHXXRatio - 1.0;
8703 dBrHXXRatio2 = 0.0;
8704 } else if (fstate == 4){
8705 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8706 dBrHXXRatio1 = BrHXXRatio - 1.0;
8707 dBrHXXRatio2 = 0.0;
8708 } else if (fstate == 5){
8709 BrHXXRatio = (myNPbase->BrHtautauRatio());
8710 dBrHXXRatio1 = BrHXXRatio - 1.0;
8711 dBrHXXRatio2 = 0.0;
8712 } else if (fstate == 6){
8713 BrHXXRatio = (myNPbase->BrHWWRatio());
8714 dBrHXXRatio1 = BrHXXRatio - 1.0;
8715 dBrHXXRatio2 = 0.0;
8716 } else if (fstate == 7){
8717 BrHXXRatio = (myNPbase->BrHZZRatio());
8718 dBrHXXRatio1 = BrHXXRatio - 1.0;
8719 dBrHXXRatio2 = 0.0;
8720 } else {
8721 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8722 }
8723
8724 //-- Production x Decay:
8725 if ((this->getModel()).isModelLinearized()){
8726 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8727 } else if((this->getModel()).isModelNPquadratic()){
8728 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8729 } else {
8730 return weight*(muProd)*(BrHXXRatio);
8731 }
8732
8733}
8734
8735
8736// -----------------------------------------------------------------------------
8737
8738STXS12_ggHll_pTV0_75::STXS12_ggHll_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8739: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8740{
8741 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8742 throw std::runtime_error("STXS12_ggHll_pTV0_75 called with a class whose parent is not NPbase");
8743
8744}
8745
8747{
8748 double BrHXXRatio = 1.0;
8749 if (fstate == 1){
8750 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8751 } else if (fstate == 2){
8752 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8753 } else if (fstate == 3){
8754 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8755 } else if (fstate == 4){
8756 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8757 } else {
8758 throw std::runtime_error("STXS12_ggHll_pTV0_75 called with invalid argument for final state in fstate_i");
8759 }
8760
8761 if ((this->getModel()).isModelLinearized()) {
8762 return ((myNPbase->STXS12_ggHll_pTV0_75(sqrt_s)) + (BrHXXRatio) - 1.0);
8763 } else {
8764 return (myNPbase->STXS12_ggHll_pTV0_75(sqrt_s))*(BrHXXRatio);
8765 }
8766}
8767
8768// -----------------------------------------------------------------------------
8769
8770STXS12_ggHll_pTV75_150::STXS12_ggHll_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8771: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8772{
8773 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8774 throw std::runtime_error("STXS12_ggHll_pTV75_150 called with a class whose parent is not NPbase");
8775
8776}
8777
8779{
8780 double BrHXXRatio = 1.0;
8781 if (fstate == 1){
8782 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8783 } else if (fstate == 2){
8784 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8785 } else if (fstate == 3){
8786 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8787 } else if (fstate == 4){
8788 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8789 } else {
8790 throw std::runtime_error("STXS12_ggHll_pTV75_150 called with invalid argument for final state in fstate_i");
8791 }
8792
8793 if ((this->getModel()).isModelLinearized()) {
8794 return ((myNPbase->STXS12_ggHll_pTV75_150(sqrt_s)) + (BrHXXRatio) - 1.0);
8795 } else {
8796 return (myNPbase->STXS12_ggHll_pTV75_150(sqrt_s))*(BrHXXRatio);
8797 }
8798}
8799
8800// -----------------------------------------------------------------------------
8801
8802STXS12_ggHll_pTV150_250_Nj0::STXS12_ggHll_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8803: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8804{
8805 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8806 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj0 called with a class whose parent is not NPbase");
8807
8808}
8809
8811{
8812 double BrHXXRatio = 1.0;
8813 if (fstate == 1){
8814 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8815 } else if (fstate == 2){
8816 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8817 } else if (fstate == 3){
8818 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8819 } else if (fstate == 4){
8820 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8821 } else {
8822 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
8823 }
8824
8825 if ((this->getModel()).isModelLinearized()) {
8826 return ((myNPbase->STXS12_ggHll_pTV150_250_Nj0(sqrt_s)) + (BrHXXRatio) - 1.0);
8827 } else {
8828 return (myNPbase->STXS12_ggHll_pTV150_250_Nj0(sqrt_s))*(BrHXXRatio);
8829 }
8830}
8831
8832// -----------------------------------------------------------------------------
8833
8834STXS12_ggHll_pTV150_250_Nj1::STXS12_ggHll_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8835: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8836{
8837 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8838 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj1 called with a class whose parent is not NPbase");
8839
8840}
8841
8843{
8844 double BrHXXRatio = 1.0;
8845 if (fstate == 1){
8846 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8847 } else if (fstate == 2){
8848 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8849 } else if (fstate == 3){
8850 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8851 } else if (fstate == 4){
8852 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8853 } else {
8854 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
8855 }
8856
8857 if ((this->getModel()).isModelLinearized()) {
8858 return ((myNPbase->STXS12_ggHll_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
8859 } else {
8860 return (myNPbase->STXS12_ggHll_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
8861 }
8862}
8863
8864// -----------------------------------------------------------------------------
8865
8866STXS12_ggHll_pTV250_Inf::STXS12_ggHll_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8867: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8868{
8869 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8870 throw std::runtime_error("STXS12_ggHll_pTV250_Inf called with a class whose parent is not NPbase");
8871
8872}
8873
8875{
8876 double BrHXXRatio = 1.0;
8877 if (fstate == 1){
8878 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8879 } else if (fstate == 2){
8880 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8881 } else if (fstate == 3){
8882 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8883 } else if (fstate == 4){
8884 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8885 } else {
8886 throw std::runtime_error("STXS12_ggHll_pTV250_Inf called with invalid argument for final state in fstate_i");
8887 }
8888
8889 if ((this->getModel()).isModelLinearized()) {
8890 return ((myNPbase->STXS12_ggHll_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
8891 } else {
8892 return (myNPbase->STXS12_ggHll_pTV250_Inf(sqrt_s))*(BrHXXRatio);
8893 }
8894}
8895
8896// -----------------------------------------------------------------------------
8897
8898STXS12_qqHqq_Nj0::STXS12_qqHqq_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8899: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8900{
8901 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8902 throw std::runtime_error("STXS12_qqHqq_Nj0 called with a class whose parent is not NPbase");
8903
8904}
8905
8907{
8908 double BrHXXRatio = 1.0;
8909 if (fstate == 1){
8910 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8911 } else if (fstate == 2){
8912 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8913 } else if (fstate == 3){
8914 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8915 } else if (fstate == 4){
8916 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8917 } else {
8918 throw std::runtime_error("STXS12_qqHqq_Nj called with invalid argument for final state in fstate_i");
8919 }
8920
8921 if ((this->getModel()).isModelLinearized()) {
8922 return ((myNPbase->STXS12_qqHqq_Nj0(sqrt_s)) + (BrHXXRatio) - 1.0);
8923 } else {
8924 return (myNPbase->STXS12_qqHqq_Nj0(sqrt_s))*(BrHXXRatio);
8925 }
8926}
8927
8928// -----------------------------------------------------------------------------
8929
8930STXS12_qqHqq_Nj1::STXS12_qqHqq_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8931: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8932{
8933 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8934 throw std::runtime_error("STXS12_qqHqq_Nj1 called with a class whose parent is not NPbase");
8935
8936}
8937
8939{
8940 double BrHXXRatio = 1.0;
8941 if (fstate == 1){
8942 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8943 } else if (fstate == 2){
8944 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8945 } else if (fstate == 3){
8946 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8947 } else if (fstate == 4){
8948 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8949 } else {
8950 throw std::runtime_error("STXS12_qqHqq_Nj1 called with invalid argument for final state in fstate_i");
8951 }
8952
8953 if ((this->getModel()).isModelLinearized()) {
8954 return ((myNPbase->STXS12_qqHqq_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
8955 } else {
8956 return (myNPbase->STXS12_qqHqq_Nj1(sqrt_s))*(BrHXXRatio);
8957 }
8958}
8959
8960// -----------------------------------------------------------------------------
8961
8962STXS12_qqHqq_mjj0_60_Nj2::STXS12_qqHqq_mjj0_60_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8963: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8964{
8965 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8966 throw std::runtime_error("STXS12_qqHqq_mjj0_60_Nj2 called with a class whose parent is not NPbase");
8967
8968}
8969
8971{
8972 double BrHXXRatio = 1.0;
8973 if (fstate == 1){
8974 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8975 } else if (fstate == 2){
8976 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8977 } else if (fstate == 3){
8978 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8979 } else if (fstate == 4){
8980 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8981 } else {
8982 throw std::runtime_error("STXS12_qqHqq_mjj0_60_Nj2 called with invalid argument for final state in fstate_i");
8983 }
8984
8985 if ((this->getModel()).isModelLinearized()) {
8986 return ((myNPbase->STXS12_qqHqq_mjj0_60_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8987 } else {
8988 return (myNPbase->STXS12_qqHqq_mjj0_60_Nj2(sqrt_s))*(BrHXXRatio);
8989 }
8990}
8991
8992
8993
8994// -----------------------------------------------------------------------------
8995
8996
8997//VM:STXS2024;
8998STXS12_qqHqq_VH_veto_Nj01::STXS12_qqHqq_VH_veto_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8999: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9000{
9001 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9002 throw std::runtime_error("STXS12_qqHqq_VH_veto_Nj01 called with a class whose parent is not NPbase");
9003
9004}
9005
9007{
9008 //-- Production:
9009 double weight = 1.0; //If normalized to the SM
9010 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9011 double muProd = myNPbase->STXS12_qqHqq_VH_veto_Nj01(sqrt_s);
9012 double muProd1 = muProd -1.0;
9013 double muProd2 = 0.0;
9014
9015 //-- Decay:
9016 double BrHXXRatio = 1.0;
9017 double dBrHXXRatio1 = 0.0;
9018 double dBrHXXRatio2 = 0.0;
9019 if (fstate==0){
9020 // Use for Cross-section [pb] with no Higgs-boson decay
9021 weight = (1.); //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9022 } else if (fstate == 1){
9023 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9024 dBrHXXRatio1 = BrHXXRatio - 1.0;
9025 dBrHXXRatio2 = 0.0;
9026 } else if (fstate == 2){
9027 BrHXXRatio = (myNPbase->BrHgagaRatio());
9028 dBrHXXRatio1 = BrHXXRatio - 1.0;
9029 dBrHXXRatio2 = 0.0;
9030 } else if (fstate == 3){
9031 BrHXXRatio = (myNPbase->BrHbbRatio());
9032 dBrHXXRatio1 = BrHXXRatio - 1.0;
9033 dBrHXXRatio2 = 0.0;
9034 } else if (fstate == 4){
9035 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9036 dBrHXXRatio1 = BrHXXRatio - 1.0;
9037 dBrHXXRatio2 = 0.0;
9038 } else if (fstate == 5){
9039 BrHXXRatio = (myNPbase->BrHtautauRatio());
9040 dBrHXXRatio1 = BrHXXRatio - 1.0;
9041 dBrHXXRatio2 = 0.0;
9042 } else if (fstate == 6){
9043 BrHXXRatio = (myNPbase->BrHWWRatio());
9044 dBrHXXRatio1 = BrHXXRatio - 1.0;
9045 dBrHXXRatio2 = 0.0;
9046 } else if (fstate == 7){
9047 BrHXXRatio = (myNPbase->BrHZZRatio());
9048 dBrHXXRatio1 = BrHXXRatio - 1.0;
9049 dBrHXXRatio2 = 0.0;
9050 } else {
9051 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
9052 }
9053
9054 //-- Production x Decay:
9055 if ((this->getModel()).isModelLinearized()){
9056 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9057 } else if((this->getModel()).isModelNPquadratic()){
9058 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9059 } else {
9060 return weight*(muProd)*(BrHXXRatio);
9061 }
9062
9063}
9064
9065
9066
9067
9068// -----------------------------------------------------------------------------
9069
9070
9071//VM:STXS2024;
9072STXS12_qqHqq_VH_had_Nj2::STXS12_qqHqq_VH_had_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9073: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9074{
9075 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9076 throw std::runtime_error("STXS12_qqHqq_VH_had_Nj2 called with a class whose parent is not NPbase");
9077
9078}
9079
9081{
9082 //-- Production:
9083 double weight = 1.0; //If normalized to the SM
9084 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9085 double muProd = myNPbase->STXS12_qqHqq_VH_had_Nj2(sqrt_s);
9086 double muProd1 = muProd -1.0;
9087 double muProd2 = 0.0;
9088
9089 //-- Decay:
9090 double BrHXXRatio = 1.0;
9091 double dBrHXXRatio1 = 0.0;
9092 double dBrHXXRatio2 = 0.0;
9093 if (fstate==0){
9094 // Use for Cross-section [pb] with no Higgs-boson decay
9095 weight = (1.); //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9096 } else if (fstate == 1){
9097 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9098 dBrHXXRatio1 = BrHXXRatio - 1.0;
9099 dBrHXXRatio2 = 0.0;
9100 } else if (fstate == 2){
9101 BrHXXRatio = (myNPbase->BrHgagaRatio());
9102 dBrHXXRatio1 = BrHXXRatio - 1.0;
9103 dBrHXXRatio2 = 0.0;
9104 } else if (fstate == 3){
9105 BrHXXRatio = (myNPbase->BrHbbRatio());
9106 dBrHXXRatio1 = BrHXXRatio - 1.0;
9107 dBrHXXRatio2 = 0.0;
9108 } else if (fstate == 4){
9109 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9110 dBrHXXRatio1 = BrHXXRatio - 1.0;
9111 dBrHXXRatio2 = 0.0;
9112 } else if (fstate == 5){
9113 BrHXXRatio = (myNPbase->BrHtautauRatio());
9114 dBrHXXRatio1 = BrHXXRatio - 1.0;
9115 dBrHXXRatio2 = 0.0;
9116 } else if (fstate == 6){
9117 BrHXXRatio = (myNPbase->BrHWWRatio());
9118 dBrHXXRatio1 = BrHXXRatio - 1.0;
9119 dBrHXXRatio2 = 0.0;
9120 } else if (fstate == 7){
9121 BrHXXRatio = (myNPbase->BrHZZRatio());
9122 dBrHXXRatio1 = BrHXXRatio - 1.0;
9123 dBrHXXRatio2 = 0.0;
9124 } else {
9125 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
9126 }
9127
9128 //-- Production x Decay:
9129 if ((this->getModel()).isModelLinearized()){
9130 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9131 } else if((this->getModel()).isModelNPquadratic()){
9132 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9133 } else {
9134 return weight*(muProd)*(BrHXXRatio);
9135 }
9136
9137}
9138
9139
9140
9141// -----------------------------------------------------------------------------
9142
9143//AG:STXS2024
9144STXS12_qqHqq_mjj60_120_Nj2::STXS12_qqHqq_mjj60_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9145: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9146{
9147 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9148 throw std::runtime_error("STXS12_qqHqq_mjj60_120_Nj2 called with a class whose parent is not NPbase");
9149
9150}
9151
9153{
9154 //-- Production:
9155 double weight = 1.0; //If normalized to the SM
9156 double muProd = myNPbase->STXS12_qqHqq_mjj60_120_Nj2(sqrt_s);
9157 double muProd1 = muProd -1.0;
9158 double muProd2 = 0.0;
9159
9160 //-- Decay:
9161 double BrHXXRatio = 1.0;
9162 double dBrHXXRatio1 = 0.0;
9163 double dBrHXXRatio2 = 0.0;
9164 if (fstate==0){
9165 // Use for Cross-section [pb] with no Higgs-boson decay
9166 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9167 } else if (fstate == 1){
9168 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9169 dBrHXXRatio1 = BrHXXRatio - 1.0;
9170 dBrHXXRatio2 = 0.0;
9171 } else if (fstate == 2){
9172 BrHXXRatio = (myNPbase->BrHgagaRatio());
9173 dBrHXXRatio1 = BrHXXRatio - 1.0;
9174 dBrHXXRatio2 = 0.0;
9175 } else if (fstate == 3){
9176 BrHXXRatio = (myNPbase->BrHbbRatio());
9177 dBrHXXRatio1 = BrHXXRatio - 1.0;
9178 dBrHXXRatio2 = 0.0;
9179 } else if (fstate == 4){
9180 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9181 dBrHXXRatio1 = BrHXXRatio - 1.0;
9182 dBrHXXRatio2 = 0.0;
9183 } else if (fstate == 5){
9184 BrHXXRatio = (myNPbase->BrHtautauRatio());
9185 dBrHXXRatio1 = BrHXXRatio - 1.0;
9186 dBrHXXRatio2 = 0.0;
9187 } else if (fstate == 6){
9188 BrHXXRatio = (myNPbase->BrHWWRatio());
9189 dBrHXXRatio1 = BrHXXRatio - 1.0;
9190 dBrHXXRatio2 = 0.0;
9191 } else if (fstate == 7){
9192 BrHXXRatio = (myNPbase->BrHZZRatio());
9193 dBrHXXRatio1 = BrHXXRatio - 1.0;
9194 dBrHXXRatio2 = 0.0;
9195 } else {
9196 throw std::runtime_error("STXS12_qqHqq_mjj60_120_Nj2 called with invalid argument for final state in fstate_i");
9197 }
9198
9199 //-- Production x Decay:
9200 if ((this->getModel()).isModelLinearized()){
9201 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9202 } else if((this->getModel()).isModelNPquadratic()){
9203 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9204 } else {
9205 return weight*(muProd)*(BrHXXRatio);
9206 }
9207}
9208
9209// -----------------------------------------------------------------------------
9210
9211STXS12_qqHqq_mjj120_350_Nj2::STXS12_qqHqq_mjj120_350_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9212: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9213{
9214 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9215 throw std::runtime_error("STXS12_qqHqq_mjj120_350_Nj2 called with a class whose parent is not NPbase");
9216
9217}
9218
9220{
9221 double BrHXXRatio = 1.0;
9222 if (fstate == 1){
9223 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9224 } else if (fstate == 2){
9225 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9226 } else if (fstate == 3){
9227 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9228 } else if (fstate == 4){
9229 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9230 } else {
9231 throw std::runtime_error("STXS12_qqHqq_mjj120_350_Nj2 called with invalid argument for final state in fstate_i");
9232 }
9233
9234 if ((this->getModel()).isModelLinearized()) {
9235 return ((myNPbase->STXS12_qqHqq_mjj120_350_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9236 } else {
9237 return (myNPbase->STXS12_qqHqq_mjj120_350_Nj2(sqrt_s))*(BrHXXRatio);
9238 }
9239}
9240
9241// -----------------------------------------------------------------------------
9242
9243//AG:STXS2024
9245: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9246{
9247 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9248 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9249
9250}
9251
9253{
9254 //-- Production:
9255 double weight = 1.0; //If normalized to the SM
9257 double muProd1 = muProd -1.0;
9258 double muProd2 = 0.0;
9259
9260 //-- Decay:
9261 double BrHXXRatio = 1.0;
9262 double dBrHXXRatio1 = 0.0;
9263 double dBrHXXRatio2 = 0.0;
9264 if (fstate==0){
9265 // Use for Cross-section [pb] with no Higgs-boson decay
9266 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9267 } else if (fstate == 1){
9268 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9269 dBrHXXRatio1 = BrHXXRatio - 1.0;
9270 dBrHXXRatio2 = 0.0;
9271 } else if (fstate == 2){
9272 BrHXXRatio = (myNPbase->BrHgagaRatio());
9273 dBrHXXRatio1 = BrHXXRatio - 1.0;
9274 dBrHXXRatio2 = 0.0;
9275 } else if (fstate == 3){
9276 BrHXXRatio = (myNPbase->BrHbbRatio());
9277 dBrHXXRatio1 = BrHXXRatio - 1.0;
9278 dBrHXXRatio2 = 0.0;
9279 } else if (fstate == 4){
9280 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9281 dBrHXXRatio1 = BrHXXRatio - 1.0;
9282 dBrHXXRatio2 = 0.0;
9283 } else if (fstate == 5){
9284 BrHXXRatio = (myNPbase->BrHtautauRatio());
9285 dBrHXXRatio1 = BrHXXRatio - 1.0;
9286 dBrHXXRatio2 = 0.0;
9287 } else if (fstate == 6){
9288 BrHXXRatio = (myNPbase->BrHWWRatio());
9289 dBrHXXRatio1 = BrHXXRatio - 1.0;
9290 dBrHXXRatio2 = 0.0;
9291 } else if (fstate == 7){
9292 BrHXXRatio = (myNPbase->BrHZZRatio());
9293 dBrHXXRatio1 = BrHXXRatio - 1.0;
9294 dBrHXXRatio2 = 0.0;
9295 } else {
9296 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9297 }
9298
9299
9300 //-- Production x Decay:
9301 if ((this->getModel()).isModelLinearized()){
9302 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9303 } else if((this->getModel()).isModelNPquadratic()){
9304 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9305 } else {
9306 return weight*(muProd)*(BrHXXRatio);
9307 }
9308
9309}
9310
9311// -----------------------------------------------------------------------------
9312
9314: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9315{
9316 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9317 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 called with a class whose parent is not NPbase");
9318
9319}
9320
9322{
9323 double BrHXXRatio = 1.0;
9324 if (fstate == 1){
9325 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9326 } else if (fstate == 2){
9327 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9328 } else if (fstate == 3){
9329 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9330 } else if (fstate == 4){
9331 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9332 } else {
9333 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
9334 }
9335
9336 if ((this->getModel()).isModelLinearized()) {
9337 return ((myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9338 } else {
9340 }
9341}
9342
9343// -----------------------------------------------------------------------------
9344
9346: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9347{
9348 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9349 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9350
9351}
9352
9354{
9355 double BrHXXRatio = 1.0;
9356 if (fstate == 1){
9357 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9358 } else if (fstate == 2){
9359 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9360 } else if (fstate == 3){
9361 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9362 } else if (fstate == 4){
9363 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9364 } else {
9365 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9366 }
9367
9368 if ((this->getModel()).isModelLinearized()) {
9369 return ((myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9370 } else {
9372 }
9373}
9374
9375// -----------------------------------------------------------------------------
9376
9378: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9379{
9380 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9381 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 called with a class whose parent is not NPbase");
9382
9383}
9384
9386{
9387 double BrHXXRatio = 1.0;
9388 if (fstate == 1){
9389 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9390 } else if (fstate == 2){
9391 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9392 } else if (fstate == 3){
9393 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9394 } else if (fstate == 4){
9395 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9396 } else {
9397 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
9398 }
9399
9400 if ((this->getModel()).isModelLinearized()) {
9401 return ((myNPbase->STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9402 } else {
9404 }
9405}
9406
9407// -----------------------------------------------------------------------------
9408
9410: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9411{
9412 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9413 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9414
9415}
9416
9418{
9419 double BrHXXRatio = 1.0;
9420 if (fstate == 1){
9421 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9422 } else if (fstate == 2){
9423 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9424 } else if (fstate == 3){
9425 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9426 } else if (fstate == 4){
9427 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9428 } else {
9429 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9430 }
9431
9432 if ((this->getModel()).isModelLinearized()) {
9433 return ((myNPbase->STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9434 } else {
9436 }
9437}
9438
9439// -----------------------------------------------------------------------------
9440
9441//AG:STXS2024
9442STXS12_qqHqq_mjj350_700_pTH0_200_Nj2::STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9443: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9444{
9445 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9446 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9447
9448}
9449
9451{
9452 //-- Production:
9453 double weight = 1.0; //If normalized to the SM
9455 double muProd1 = muProd -1.0;
9456 double muProd2 = 0.0;
9457
9458 //-- Decay:
9459 double BrHXXRatio = 1.0;
9460 double dBrHXXRatio1 = 0.0;
9461 double dBrHXXRatio2 = 0.0;
9462 if (fstate==0){
9463 // Use for Cross-section [pb] with no Higgs-boson decay
9464 weight = 0.53537; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9465 } else if (fstate == 1){
9466 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9467 dBrHXXRatio1 = BrHXXRatio - 1.0;
9468 dBrHXXRatio2 = 0.0;
9469 } else if (fstate == 2){
9470 BrHXXRatio = (myNPbase->BrHgagaRatio());
9471 dBrHXXRatio1 = BrHXXRatio - 1.0;
9472 dBrHXXRatio2 = 0.0;
9473 } else if (fstate == 3){
9474 BrHXXRatio = (myNPbase->BrHbbRatio());
9475 dBrHXXRatio1 = BrHXXRatio - 1.0;
9476 dBrHXXRatio2 = 0.0;
9477 } else if (fstate == 4){
9478 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9479 dBrHXXRatio1 = BrHXXRatio - 1.0;
9480 dBrHXXRatio2 = 0.0;
9481 } else if (fstate == 5){
9482 BrHXXRatio = (myNPbase->BrHtautauRatio());
9483 dBrHXXRatio1 = BrHXXRatio - 1.0;
9484 dBrHXXRatio2 = 0.0;
9485 } else if (fstate == 6){
9486 BrHXXRatio = (myNPbase->BrHWWRatio());
9487 dBrHXXRatio1 = BrHXXRatio - 1.0;
9488 dBrHXXRatio2 = 0.0;
9489 } else {
9490 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9491 }
9492
9493 //-- Production x Decay:
9494 if ((this->getModel()).isModelLinearized()){
9495 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9496 } else if((this->getModel()).isModelNPquadratic()){
9497 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9498 } else {
9499 return weight*(muProd)*(BrHXXRatio);
9500 }
9501
9502
9503}
9504
9505// -----------------------------------------------------------------------------
9506
9507//AG:STXS2024
9508STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2::STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9509: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9510{
9511 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9512 throw std::runtime_error("STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9513
9514}
9515
9517{
9518 //-- Production:
9519 double weight = 1.0; //If normalized to the SM
9521 double muProd1 = muProd -1.0;
9522 double muProd2 = 0.0;
9523
9524 //-- Decay:
9525 double BrHXXRatio = 1.0;
9526 double dBrHXXRatio1 = 0.0;
9527 double dBrHXXRatio2 = 0.0;
9528 if (fstate==0){
9529 // Use for Cross-section [pb] with no Higgs-boson decay
9530 weight = 0.25614; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9531 } else if (fstate == 1){
9532 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9533 dBrHXXRatio1 = BrHXXRatio - 1.0;
9534 dBrHXXRatio2 = 0.0;
9535 } else if (fstate == 2){
9536 BrHXXRatio = (myNPbase->BrHgagaRatio());
9537 dBrHXXRatio1 = BrHXXRatio - 1.0;
9538 dBrHXXRatio2 = 0.0;
9539 } else if (fstate == 3){
9540 BrHXXRatio = (myNPbase->BrHbbRatio());
9541 dBrHXXRatio1 = BrHXXRatio - 1.0;
9542 dBrHXXRatio2 = 0.0;
9543 } else if (fstate == 4){
9544 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9545 dBrHXXRatio1 = BrHXXRatio - 1.0;
9546 dBrHXXRatio2 = 0.0;
9547 } else if (fstate == 5){
9548 BrHXXRatio = (myNPbase->BrHtautauRatio());
9549 dBrHXXRatio1 = BrHXXRatio - 1.0;
9550 dBrHXXRatio2 = 0.0;
9551 } else if (fstate == 6){
9552 BrHXXRatio = (myNPbase->BrHWWRatio());
9553 dBrHXXRatio1 = BrHXXRatio - 1.0;
9554 dBrHXXRatio2 = 0.0;
9555 } else {
9556 throw std::runtime_error("STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9557 }
9558
9559 //-- Production x Decay:
9560 if ((this->getModel()).isModelLinearized()){
9561 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9562 } else if((this->getModel()).isModelNPquadratic()){
9563 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9564 } else {
9565 return weight*(muProd)*(BrHXXRatio);
9566 }
9567
9568
9569}
9570
9571// -----------------------------------------------------------------------------
9572
9573//AG:STXS2024
9574STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2::STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9575: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9576{
9577 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9578 throw std::runtime_error("STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9579
9580}
9581
9583{
9584 //-- Production:
9585 double weight = 1.0; //If normalized to the SM
9587 double muProd1 = muProd -1.0;
9588 double muProd2 = 0.0;
9589
9590 //-- Decay:
9591 double BrHXXRatio = 1.0;
9592 double dBrHXXRatio1 = 0.0;
9593 double dBrHXXRatio2 = 0.0;
9594 if (fstate==0){
9595 // Use for Cross-section [pb] with no Higgs-boson decay
9596 weight = 0.22408; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9597 } else if (fstate == 1){
9598 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9599 dBrHXXRatio1 = BrHXXRatio - 1.0;
9600 dBrHXXRatio2 = 0.0;
9601 } else if (fstate == 2){
9602 BrHXXRatio = (myNPbase->BrHgagaRatio());
9603 dBrHXXRatio1 = BrHXXRatio - 1.0;
9604 dBrHXXRatio2 = 0.0;
9605 } else if (fstate == 3){
9606 BrHXXRatio = (myNPbase->BrHbbRatio());
9607 dBrHXXRatio1 = BrHXXRatio - 1.0;
9608 dBrHXXRatio2 = 0.0;
9609 } else if (fstate == 4){
9610 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9611 dBrHXXRatio1 = BrHXXRatio - 1.0;
9612 dBrHXXRatio2 = 0.0;
9613 } else if (fstate == 5){
9614 BrHXXRatio = (myNPbase->BrHtautauRatio());
9615 dBrHXXRatio1 = BrHXXRatio - 1.0;
9616 dBrHXXRatio2 = 0.0;
9617 } else if (fstate == 6){
9618 BrHXXRatio = (myNPbase->BrHWWRatio());
9619 dBrHXXRatio1 = BrHXXRatio - 1.0;
9620 dBrHXXRatio2 = 0.0;
9621 } else {
9622 throw std::runtime_error("STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9623 }
9624
9625 //-- Production x Decay:
9626 if ((this->getModel()).isModelLinearized()){
9627 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9628 } else if((this->getModel()).isModelNPquadratic()){
9629 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9630 } else {
9631 return weight*(muProd)*(BrHXXRatio);
9632 }
9633
9634
9635}
9636
9637// -----------------------------------------------------------------------------
9638
9639//AG:STXS2024
9640STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2::STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9641: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9642{
9643 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9644 throw std::runtime_error("STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9645
9646}
9647
9649{
9650 //-- Production:
9651 double weight = 1.0; //If normalized to the SM
9653 double muProd1 = muProd -1.0;
9654 double muProd2 = 0.0;
9655
9656 //-- Decay:
9657 double BrHXXRatio = 1.0;
9658 double dBrHXXRatio1 = 0.0;
9659 double dBrHXXRatio2 = 0.0;
9660 if (fstate==0){
9661 // Use for Cross-section [pb] with no Higgs-boson decay
9662 weight = 0.21578; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9663 } else if (fstate == 1){
9664 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9665 dBrHXXRatio1 = BrHXXRatio - 1.0;
9666 dBrHXXRatio2 = 0.0;
9667 } else if (fstate == 2){
9668 BrHXXRatio = (myNPbase->BrHgagaRatio());
9669 dBrHXXRatio1 = BrHXXRatio - 1.0;
9670 dBrHXXRatio2 = 0.0;
9671 } else if (fstate == 3){
9672 BrHXXRatio = (myNPbase->BrHbbRatio());
9673 dBrHXXRatio1 = BrHXXRatio - 1.0;
9674 dBrHXXRatio2 = 0.0;
9675 } else if (fstate == 4){
9676 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9677 dBrHXXRatio1 = BrHXXRatio - 1.0;
9678 dBrHXXRatio2 = 0.0;
9679 } else if (fstate == 5){
9680 BrHXXRatio = (myNPbase->BrHtautauRatio());
9681 dBrHXXRatio1 = BrHXXRatio - 1.0;
9682 dBrHXXRatio2 = 0.0;
9683 } else if (fstate == 6){
9684 BrHXXRatio = (myNPbase->BrHWWRatio());
9685 dBrHXXRatio1 = BrHXXRatio - 1.0;
9686 dBrHXXRatio2 = 0.0;
9687 } else {
9688 throw std::runtime_error("STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9689 }
9690
9691 //-- Production x Decay:
9692 if ((this->getModel()).isModelLinearized()){
9693 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9694 } else if((this->getModel()).isModelNPquadratic()){
9695 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9696 } else {
9697 return weight*(muProd)*(BrHXXRatio);
9698 }
9699
9700}
9701
9702// -----------------------------------------------------------------------------
9703
9704//AG:STXS2024
9705STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2::STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9706: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9707{
9708 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9709 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9710
9711}
9712
9714{
9715 //-- Production:
9716 double weight = 1.0; //If normalized to the SM
9717 //Since adding bins, include partial weigths of SM_predictions
9718 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
9719 double muProd = (0.22408*(myNPbase->STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(sqrt_s))
9720 + 0.21578*(myNPbase->STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(sqrt_s)) / (0.30189+0.21578));
9721 double muProd1 = (0.22408*(myNPbase->STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(sqrt_s)-1.0)
9722 + 0.21578*(myNPbase->STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(sqrt_s)-1.0) / (0.30189+0.21578));
9723 double muProd2 = 0.0;
9724
9725 //-- Decay:
9726 double BrHXXRatio = 1.0;
9727 double dBrHXXRatio1 = 0.0;
9728 double dBrHXXRatio2 = 0.0;
9729 if (fstate==0){
9730 // Use for Cross-section [pb] with no Higgs-boson decay
9731 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9732 } else if (fstate == 1){
9733 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9734 dBrHXXRatio1 = BrHXXRatio - 1.0;
9735 dBrHXXRatio2 = 0.0;
9736 } else if (fstate == 2){
9737 BrHXXRatio = (myNPbase->BrHgagaRatio());
9738 dBrHXXRatio1 = BrHXXRatio - 1.0;
9739 dBrHXXRatio2 = 0.0;
9740 } else if (fstate == 3){
9741 BrHXXRatio = (myNPbase->BrHbbRatio());
9742 dBrHXXRatio1 = BrHXXRatio - 1.0;
9743 dBrHXXRatio2 = 0.0;
9744 } else if (fstate == 4){
9745 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9746 dBrHXXRatio1 = BrHXXRatio - 1.0;
9747 dBrHXXRatio2 = 0.0;
9748 } else {
9749 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9750 }
9751
9752 //-- Production x Decay:
9753 if ((this->getModel()).isModelLinearized()){
9754 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9755 } else if((this->getModel()).isModelNPquadratic()){
9756 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9757 } else {
9758 return weight*(muProd)*(BrHXXRatio);
9759 }
9760
9761
9762}
9763
9764// -----------------------------------------------------------------------------
9765
9766//AG:STXS2024
9767STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2::STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9768: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9769{
9770 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9771 throw std::runtime_error("STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9772
9773}
9774
9776{
9777 //-- Production:
9778 double weight = 1.0; //If normalized to the SM
9780 double muProd1 = muProd -1.0;
9781 double muProd2 = 0.0;
9782
9783 //-- Decay:
9784 double BrHXXRatio = 1.0;
9785 double dBrHXXRatio1 = 0.0;
9786 double dBrHXXRatio2 = 0.0;
9787 if (fstate==0){
9788 // Use for Cross-section [pb] with no Higgs-boson decay
9789 weight = 0.07372 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9790 } else if (fstate == 1){
9791 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9792 dBrHXXRatio1 = BrHXXRatio - 1.0;
9793 dBrHXXRatio2 = 0.0;
9794 } else if (fstate == 2){
9795 BrHXXRatio = (myNPbase->BrHgagaRatio());
9796 dBrHXXRatio1 = BrHXXRatio - 1.0;
9797 dBrHXXRatio2 = 0.0;
9798 } else if (fstate == 3){
9799 BrHXXRatio = (myNPbase->BrHbbRatio());
9800 dBrHXXRatio1 = BrHXXRatio - 1.0;
9801 dBrHXXRatio2 = 0.0;
9802 } else if (fstate == 4){
9803 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9804 dBrHXXRatio1 = BrHXXRatio - 1.0;
9805 dBrHXXRatio2 = 0.0;
9806 } else {
9807 throw std::runtime_error("STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9808 }
9809
9810 //-- Production x Decay:
9811 if ((this->getModel()).isModelLinearized()){
9812 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9813 } else if((this->getModel()).isModelNPquadratic()){
9814 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9815 } else {
9816 return weight*(muProd)*(BrHXXRatio);
9817 }
9818
9819
9820}
9821
9822// -----------------------------------------------------------------------------
9823
9824//AG:STXS2024
9825STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2::STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9826: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9827{
9828 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9829 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9830
9831}
9832
9834{
9835 //-- Production:
9836 double weight = 1.0; //If normalized to the SM
9838 double muProd1 = muProd -1.0;
9839 double muProd2 = 0.0;
9840
9841 //-- Decay:
9842 double BrHXXRatio = 1.0;
9843 double dBrHXXRatio1 = 0.0;
9844 double dBrHXXRatio2 = 0.0;
9845 if (fstate==0){
9846 // Use for Cross-section [pb] with no Higgs-boson decay
9847 weight = 0.07315 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9848 } else if (fstate == 1){
9849 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9850 dBrHXXRatio1 = BrHXXRatio - 1.0;
9851 dBrHXXRatio2 = 0.0;
9852 } else if (fstate == 2){
9853 BrHXXRatio = (myNPbase->BrHgagaRatio());
9854 dBrHXXRatio1 = BrHXXRatio - 1.0;
9855 dBrHXXRatio2 = 0.0;
9856 } else if (fstate == 3){
9857 BrHXXRatio = (myNPbase->BrHbbRatio());
9858 dBrHXXRatio1 = BrHXXRatio - 1.0;
9859 dBrHXXRatio2 = 0.0;
9860 } else if (fstate == 4){
9861 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9862 dBrHXXRatio1 = BrHXXRatio - 1.0;
9863 dBrHXXRatio2 = 0.0;
9864 } else {
9865 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9866 }
9867
9868 //-- Production x Decay:
9869 if ((this->getModel()).isModelLinearized()){
9870 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9871 } else if((this->getModel()).isModelNPquadratic()){
9872 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9873 } else {
9874 return weight*(muProd)*(BrHXXRatio);
9875 }
9876
9877
9878}
9879
9880// -----------------------------------------------------------------------------
9881
9882STXS12_qqHqq_mjj350_Inf_Nj2::STXS12_qqHqq_mjj350_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9883: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9884{
9885 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9886 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with a class whose parent is not NPbase");
9887
9888}
9889
9891{
9892 //-- Production:
9893 double weight = 1.0; //If normalized to the SM
9894 //Since adding bins, include partial weigths of SM_predictions
9895 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
9896
9897 double muProd = (0.53537*myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(sqrt_s)
9903 / (0.53537+0.25614+0.22408+0.21578+0.073727+0.07315) ;
9904
9905 double muProd1 = muProd - 1.;
9906 double muProd2 = 0.0;
9907
9908 //-- Decay:
9909 double BrHXXRatio = 1.0;
9910 double dBrHXXRatio1 = 0.0;
9911 double dBrHXXRatio2 = 0.0;
9912 if (fstate==0){
9913 // Use for Cross-section [pb] with no Higgs-boson decay
9914 weight = (0.53537+0.25614+0.22408+0.21578+0.073727+0.07315); //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9915 } else if (fstate == 1){
9916 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9917 dBrHXXRatio1 = BrHXXRatio - 1.0;
9918 dBrHXXRatio2 = 0.0;
9919 } else if (fstate == 2){
9920 BrHXXRatio = (myNPbase->BrHgagaRatio());
9921 dBrHXXRatio1 = BrHXXRatio - 1.0;
9922 dBrHXXRatio2 = 0.0;
9923 } else if (fstate == 3){
9924 BrHXXRatio = (myNPbase->BrHbbRatio());
9925 dBrHXXRatio1 = BrHXXRatio - 1.0;
9926 dBrHXXRatio2 = 0.0;
9927 } else if (fstate == 4){
9928 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9929 dBrHXXRatio1 = BrHXXRatio - 1.0;
9930 dBrHXXRatio2 = 0.0;
9931 } else if (fstate == 5){
9932 BrHXXRatio = (myNPbase->BrHtautauRatio());
9933 dBrHXXRatio1 = BrHXXRatio - 1.0;
9934 dBrHXXRatio2 = 0.0;
9935 } else {
9936 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
9937 }
9938
9939
9940
9941
9942 //-- Production x Decay:
9943 if ((this->getModel()).isModelLinearized()){
9944// std::cout<<"\033[1;31m CHECK IF LINEAR \033[0m" << std::endl;
9945 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9946 } else if((this->getModel()).isModelNPquadratic()){
9947// std::cout<<"\033[1;31m CHECK IF QUADRATIC \033[0m" << std::endl;
9948 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9949 } else {
9950// std::cout<<"\033[1;31m CHECK IF NEITHER LINEAR NOR QUADRATIC \033[0m" << std::endl;
9951 return weight*(muProd)*(BrHXXRatio);
9952 }
9953
9954}
9955
9956// -----------------------------------------------------------------------------
9957
9958STXS12_qqHlv_pTV0_75::STXS12_qqHlv_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9959: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9960{
9961 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9962 throw std::runtime_error("STXS12_qqHlv_pTV0_75 called with a class whose parent is not NPbase");
9963
9964}
9965
9967{
9968 //-- Production:
9969 double weight = 1.0; //If normalized to the SM
9970 double muProd = myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s);
9971 double muProd1 = muProd -1.0;
9972 double muProd2 = 0.0;
9973
9974 //-- Decay:
9975 double BrHXXRatio = 1.0;
9976 double dBrHXXRatio1 = 0.0;
9977 double dBrHXXRatio2 = 0.0;
9978 if (fstate==0){
9979 // Use for Cross-section [pb] with no Higgs-boson decay
9980 weight = 0.21509; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9981 } else if (fstate == 1){
9982 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9983 dBrHXXRatio1 = BrHXXRatio - 1.0;
9984 dBrHXXRatio2 = 0.0;
9985 } else if (fstate == 2){
9986 BrHXXRatio = (myNPbase->BrHgagaRatio());
9987 dBrHXXRatio1 = BrHXXRatio - 1.0;
9988 dBrHXXRatio2 = 0.0;
9989 } else if (fstate == 3){
9990 BrHXXRatio = (myNPbase->BrHbbRatio());
9991 dBrHXXRatio1 = BrHXXRatio - 1.0;
9992 dBrHXXRatio2 = 0.0;
9993 } else if (fstate == 4){
9994 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9995 dBrHXXRatio1 = BrHXXRatio - 1.0;
9996 dBrHXXRatio2 = 0.0;
9997 } else if (fstate == 5){
9998 BrHXXRatio = (myNPbase->BrHtautauRatio());
9999 dBrHXXRatio1 = BrHXXRatio - 1.0;
10000 dBrHXXRatio2 = 0.0;
10001 } else {
10002 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
10003 }
10004
10005 //-- Production x Decay:
10006 if ((this->getModel()).isModelLinearized()){
10007 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10008 } else if((this->getModel()).isModelNPquadratic()){
10009 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10010 } else {
10011 return weight*(muProd)*(BrHXXRatio);
10012 }
10013
10014}
10015
10016// -----------------------------------------------------------------------------
10017
10018STXS12_qqHlv_pTV75_150::STXS12_qqHlv_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10019: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10020{
10021 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10022 throw std::runtime_error("STXS12_qqHlv_pTV75_150 called with a class whose parent is not NPbase");
10023
10024}
10025
10027{
10028 //-- Production:
10029 double weight = 1.0; //If normalized to the SM
10030 double muProd = myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s);
10031 double muProd1 = muProd -1.0;
10032 double muProd2 = 0.0;
10033
10034 //-- Decay:
10035 double BrHXXRatio = 1.0;
10036 double dBrHXXRatio1 = 0.0;
10037 double dBrHXXRatio2 = 0.0;
10038 if (fstate==0){
10039 // Use for Cross-section [pb] with no Higgs-boson decay
10040 weight = 0.13440; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10041 } else if (fstate == 1){
10042 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10043 dBrHXXRatio1 = BrHXXRatio - 1.0;
10044 dBrHXXRatio2 = 0.0;
10045 } else if (fstate == 2){
10046 BrHXXRatio = (myNPbase->BrHgagaRatio());
10047 dBrHXXRatio1 = BrHXXRatio - 1.0;
10048 dBrHXXRatio2 = 0.0;
10049 } else if (fstate == 3){
10050 BrHXXRatio = (myNPbase->BrHbbRatio());
10051 dBrHXXRatio1 = BrHXXRatio - 1.0;
10052 dBrHXXRatio2 = 0.0;
10053 } else if (fstate == 4){
10054 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10055 dBrHXXRatio1 = BrHXXRatio - 1.0;
10056 dBrHXXRatio2 = 0.0;
10057 } else if (fstate == 5){
10058 BrHXXRatio = (myNPbase->BrHtautauRatio());
10059 dBrHXXRatio1 = BrHXXRatio - 1.0;
10060 dBrHXXRatio2 = 0.0;
10061 } else {
10062 throw std::runtime_error("STXS12_qqHlv_pTV75_150 called with invalid argument for final state in fstate_i");
10063 }
10064
10065 //-- Production x Decay:
10066 if ((this->getModel()).isModelLinearized()){
10067 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10068 } else if((this->getModel()).isModelNPquadratic()){
10069 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10070 } else {
10071 return weight*(muProd)*(BrHXXRatio);
10072 }
10073
10074}
10075
10076// -----------------------------------------------------------------------------
10077
10078//AG:STXS2024
10079STXS12_qqHlv_pTV150_250_Nj0::STXS12_qqHlv_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10080: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10081{
10082 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10083 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj0 called with a class whose parent is not NPbase");
10084
10085}
10086
10088{
10089 //-- Production:
10090 double weight = 1.0; //If normalized to the SM
10092 double muProd1 = myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s) - 1.0;
10093 double muProd2 = 0.0;
10094
10095 //-- Decay:
10096 double BrHXXRatio = 1.0;
10097 double dBrHXXRatio1 = 0.0;
10098 double dBrHXXRatio2 = 0.0;
10099 if (fstate==0){
10100 // Use for Cross-section [pb] with no Higgs-boson decay
10101 weight = 0.04117; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10102 } else if (fstate == 1){
10103 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10104 dBrHXXRatio1 = BrHXXRatio - 1.0;
10105 dBrHXXRatio2 = 0.0;
10106 } else if (fstate == 2){
10107 BrHXXRatio = (myNPbase->BrHgagaRatio());
10108 dBrHXXRatio1 = BrHXXRatio - 1.0;
10109 dBrHXXRatio2 = 0.0;
10110 } else if (fstate == 3){
10111 BrHXXRatio = (myNPbase->BrHbbRatio());
10112 dBrHXXRatio1 = BrHXXRatio - 1.0;
10113 dBrHXXRatio2 = 0.0;
10114 } else if (fstate == 4){
10115 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10116 dBrHXXRatio1 = BrHXXRatio - 1.0;
10117 dBrHXXRatio2 = 0.0;
10118 } else if (fstate == 5){
10119 BrHXXRatio = (myNPbase->BrHtautauRatio());
10120 dBrHXXRatio1 = BrHXXRatio - 1.0;
10121 dBrHXXRatio2 = 0.0;
10122 } else {
10123 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
10124 }
10125
10126 //-- Production x Decay:
10127 if ((this->getModel()).isModelLinearized()){
10128 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10129 } else if((this->getModel()).isModelNPquadratic()){
10130 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10131 } else {
10132 return weight*(muProd)*(BrHXXRatio);
10133 }
10134
10135
10136}
10137
10138// -----------------------------------------------------------------------------
10139
10140STXS12_qqHlv_pTV150_250_Nj1::STXS12_qqHlv_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10141: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10142{
10143 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10144 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj1 called with a class whose parent is not NPbase");
10145
10146}
10147
10149{
10150 double BrHXXRatio = 1.0;
10151 if (fstate == 1){
10152 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10153 } else if (fstate == 2){
10154 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10155 } else if (fstate == 3){
10156 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10157 } else if (fstate == 4){
10158 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10159 } else {
10160 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
10161 }
10162
10163 if ((this->getModel()).isModelLinearized()) {
10164 return ((myNPbase->STXS12_qqHlv_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
10165 } else {
10166 return (myNPbase->STXS12_qqHlv_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
10167 }
10168}
10169
10170// -----------------------------------------------------------------------------
10171
10172STXS12_qqHlv_pTV250_Inf::STXS12_qqHlv_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10173: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10174{
10175 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10176 throw std::runtime_error("STXS12_qqHlv_pTV250_Inf called with a class whose parent is not NPbase");
10177
10178}
10179
10181{
10182 double BrHXXRatio = 1.0;
10183 if (fstate == 1){
10184 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10185 } else if (fstate == 2){
10186 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10187 } else if (fstate == 3){
10188 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10189 } else if (fstate == 4){
10190 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10191 } else {
10192 throw std::runtime_error("STXS12_qqHlv_pTV250_Inf called with invalid argument for final state in fstate_i");
10193 }
10194
10195 if ((this->getModel()).isModelLinearized()) {
10196 return ((myNPbase->STXS12_qqHlv_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
10197 } else {
10198 return (myNPbase->STXS12_qqHlv_pTV250_Inf(sqrt_s))*(BrHXXRatio);
10199 }
10200}
10201
10202// -----------------------------------------------------------------------------
10203
10204//AG:STXS2024
10205STXS12_qqHlv_pTV0_150::STXS12_qqHlv_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10206: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10207{
10208 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10209 throw std::runtime_error("STXS12_qqHlv_pTV0_150 called with a class whose parent is not NPbase");
10210
10211}
10212
10214{
10215 //-- Production:
10216 double weight = 1.0; //If normalized to the SM
10217 //Since adding bins, include partial weigths of SM_predictions
10218 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10219 double muProd = (0.21509*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s))
10220 + 0.13440*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s))/(0.21509+0.13440));
10221 double muProd1 = (0.21509*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)-1.0)
10222 + 0.13440*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s)-1.0)/(0.21509+0.13440));
10223 double muProd2 = 0.0;
10224
10225 //-- Decay:
10226 double BrHXXRatio = 1.0;
10227 double dBrHXXRatio1 = 0.0;
10228 double dBrHXXRatio2 = 0.0;
10229 if (fstate==0){
10230 // Use for Cross-section [pb] with no Higgs-boson decay
10231 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10232 } else if (fstate == 1){
10233 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10234 dBrHXXRatio1 = BrHXXRatio - 1.0;
10235 dBrHXXRatio2 = 0.0;
10236 } else if (fstate == 2){
10237 BrHXXRatio = (myNPbase->BrHgagaRatio());
10238 dBrHXXRatio1 = BrHXXRatio - 1.0;
10239 dBrHXXRatio2 = 0.0;
10240 } else if (fstate == 3){
10241 BrHXXRatio = (myNPbase->BrHbbRatio());
10242 dBrHXXRatio1 = BrHXXRatio - 1.0;
10243 dBrHXXRatio2 = 0.0;
10244 } else if (fstate == 4){
10245 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10246 dBrHXXRatio1 = BrHXXRatio - 1.0;
10247 dBrHXXRatio2 = 0.0;
10248 } else {
10249 throw std::runtime_error("STXS12_qqHlv_pTV0_150 called with invalid argument for final state in fstate_i");
10250 }
10251
10252 //-- Production x Decay:
10253 if ((this->getModel()).isModelLinearized()){
10254 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10255 } else if((this->getModel()).isModelNPquadratic()){
10256 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10257 } else {
10258 return weight*(muProd)*(BrHXXRatio);
10259 }
10260
10261
10262}
10263
10264// -----------------------------------------------------------------------------
10265
10266//AG:STXS2024
10267STXS12_qqHlv_pTV150_Inf::STXS12_qqHlv_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10268: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10269{
10270 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10271 throw std::runtime_error("STXS12_qqHlv_pTV150_Inf called with a class whose parent is not NPbase");
10272
10273}
10274
10276{
10277 //-- Production:
10278 double weight = 1.0; //If normalized to the SM
10279 //Since adding bins, include partial weigths of SM_predictions
10280 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10281 double muProd = (0.04117 * myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s)
10283 + 0.00214 * myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s) )/(0.04117+0.01004+0.00214);
10284 double muProd1 = (0.04117 * (myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s) -1.0)
10285 + 0.01004 * (myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0)
10286 + 0.00214 * (myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s)-1.0) )/(0.04117+0.01004+0.00214);
10287 double muProd2 = 0.0;
10288
10289 //-- Decay:
10290 double BrHXXRatio = 1.0;
10291 double dBrHXXRatio1 = 0.0;
10292 double dBrHXXRatio2 = 0.0;
10293 if (fstate==0){
10294 // Use for Cross-section [pb] with no Higgs-boson decay
10295 weight = 1.0 ;
10296 } else if (fstate == 1){
10297 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10298 dBrHXXRatio1 = BrHXXRatio - 1.0;
10299 dBrHXXRatio2 = 0.0;
10300 } else if (fstate == 2){
10301 BrHXXRatio = (myNPbase->BrHgagaRatio());
10302 dBrHXXRatio1 = BrHXXRatio - 1.0;
10303 dBrHXXRatio2 = 0.0;
10304 } else if (fstate == 3){
10305 BrHXXRatio = (myNPbase->BrHbbRatio());
10306 dBrHXXRatio1 = BrHXXRatio - 1.0;
10307 dBrHXXRatio2 = 0.0;
10308 } else if (fstate == 4){
10309 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10310 dBrHXXRatio1 = BrHXXRatio - 1.0;
10311 dBrHXXRatio2 = 0.0;
10312 } else {
10313 throw std::runtime_error("STXS12_qqHlv_pTV150_Inf called with invalid argument for final state in fstate_i");
10314 }
10315
10316 //-- Production x Decay:
10317 if ((this->getModel()).isModelLinearized()){
10318 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10319 } else if((this->getModel()).isModelNPquadratic()){
10320 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10321 } else {
10322 return weight*(muProd)*(BrHXXRatio);
10323 }
10324
10325
10326}
10327
10328// -----------------------------------------------------------------------------
10329
10330//AG:STXS2024
10331STXS12_qqHlv_pTV250_400::STXS12_qqHlv_pTV250_400(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10332: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10333{
10334 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10335 throw std::runtime_error("STXS12_qqHlv_pTV250_400 called with a class whose parent is not NPbase");
10336
10337}
10338
10340{
10341 //-- Production:
10342 double weight = 1.0; //If normalized to the SM
10343 double muProd = myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s) ;
10344 double muProd1 = myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0 ;
10345 double muProd2 = 0.0;
10346
10347 //-- Decay:
10348 double BrHXXRatio = 1.0;
10349 double dBrHXXRatio1 = 0.0;
10350 double dBrHXXRatio2 = 0.0;
10351 if (fstate==0){
10352 // Use for Cross-section [pb] with no Higgs-boson decay
10353 weight =0.01004 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10354 } else if (fstate == 1){
10355 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10356 dBrHXXRatio1 = BrHXXRatio - 1.0;
10357 dBrHXXRatio2 = 0.0;
10358 } else if (fstate == 2){
10359 BrHXXRatio = (myNPbase->BrHgagaRatio());
10360 dBrHXXRatio1 = BrHXXRatio - 1.0;
10361 dBrHXXRatio2 = 0.0;
10362 } else if (fstate == 3){
10363 BrHXXRatio = (myNPbase->BrHbbRatio());
10364 dBrHXXRatio1 = BrHXXRatio - 1.0;
10365 dBrHXXRatio2 = 0.0;
10366 } else if (fstate == 4){
10367 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10368 dBrHXXRatio1 = BrHXXRatio - 1.0;
10369 dBrHXXRatio2 = 0.0;
10370 } else {
10371 throw std::runtime_error("STXS12_qqHlv_pTV250_400 called with invalid argument for final state in fstate_i");
10372 }
10373
10374 //-- Production x Decay:
10375 if ((this->getModel()).isModelLinearized()){
10376 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10377 } else if((this->getModel()).isModelNPquadratic()){
10378 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10379 } else {
10380 return weight*(muProd)*(BrHXXRatio);
10381 }
10382
10383
10384}
10385
10386// -----------------------------------------------------------------------------
10387
10388//AG:STXS2024
10389STXS12_qqHlv_pTV400_Inf::STXS12_qqHlv_pTV400_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10390: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10391{
10392 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10393 throw std::runtime_error("STXS12_qqHlv_pTV400_Inf called with a class whose parent is not NPbase");
10394
10395}
10396
10398{
10399 //-- Production:
10400 double weight = 1.0; //If normalized to the SM
10401 double muProd = myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s) ;
10402 double muProd1 = muProd-1.0 ;
10403 double muProd2 = 0.0;
10404
10405 //-- Decay:
10406 double BrHXXRatio = 1.0;
10407 double dBrHXXRatio1 = 0.0;
10408 double dBrHXXRatio2 = 0.0;
10409 if (fstate==0){
10410 // Use for Cross-section [pb] with no Higgs-boson decay
10411 weight =0.00214 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10412 } else if (fstate == 1){
10413 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10414 dBrHXXRatio1 = BrHXXRatio - 1.0;
10415 dBrHXXRatio2 = 0.0;
10416 } else if (fstate == 2){
10417 BrHXXRatio = (myNPbase->BrHgagaRatio());
10418 dBrHXXRatio1 = BrHXXRatio - 1.0;
10419 dBrHXXRatio2 = 0.0;
10420 } else if (fstate == 3){
10421 BrHXXRatio = (myNPbase->BrHbbRatio());
10422 dBrHXXRatio1 = BrHXXRatio - 1.0;
10423 dBrHXXRatio2 = 0.0;
10424 } else if (fstate == 4){
10425 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10426 dBrHXXRatio1 = BrHXXRatio - 1.0;
10427 dBrHXXRatio2 = 0.0;
10428 } else {
10429 throw std::runtime_error("STXS12_qqHlv_pTV400_Inf called with invalid argument for final state in fstate_i");
10430 }
10431
10432 //-- Production x Decay:
10433 if ((this->getModel()).isModelLinearized()){
10434 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10435 } else if((this->getModel()).isModelNPquadratic()){
10436 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10437 } else {
10438 return weight*(muProd)*(BrHXXRatio);
10439 }
10440
10441
10442}
10443
10444
10445// -----------------------------------------------------------------------------
10446
10447STXS12_qqHll_pTV0_75::STXS12_qqHll_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10448: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10449{
10450 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10451 throw std::runtime_error("STXS12_qqHll_pTV0_75 called with a class whose parent is not NPbase");
10452
10453}
10454
10456{
10457 double BrHXXRatio = 1.0;
10458 if (fstate == 1){
10459 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10460 } else if (fstate == 2){
10461 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10462 } else if (fstate == 3){
10463 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10464 } else if (fstate == 4){
10465 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10466 } else {
10467 throw std::runtime_error("STXS12_qqHll_pTV0_75 called with invalid argument for final state in fstate_i");
10468 }
10469
10470 if ((this->getModel()).isModelLinearized()) {
10471 return ((myNPbase->STXS12_qqHll_pTV0_75(sqrt_s)) + (BrHXXRatio) - 1.0);
10472 } else {
10473 return (myNPbase->STXS12_qqHll_pTV0_75(sqrt_s))*(BrHXXRatio);
10474 }
10475}
10476
10477// -----------------------------------------------------------------------------
10478
10479//AG:STXS2024
10480STXS12_qqHll_pTV75_150::STXS12_qqHll_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10481: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10482{
10483 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10484 throw std::runtime_error("STXS12_qqHll_pTV75_150 called with a class whose parent is not NPbase");
10485
10486}
10487
10489{
10490 //-- Production:
10491 double weight = 1.0; //If normalized to the SM
10492 double muProd = myNPbase->STXS12_qqHll_pTV75_150(sqrt_s);
10493 double muProd1 = muProd -1.0;
10494 double muProd2 = 0.0;
10495
10496 //-- Decay:
10497 double BrHXXRatio = 1.0;
10498 double dBrHXXRatio1 = 0.0;
10499 double dBrHXXRatio2 = 0.0;
10500 if (fstate==0){
10501 // Use for Cross-section [pb] with no Higgs-boson decay
10502 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10503 } else if (fstate == 1){
10504 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10505 dBrHXXRatio1 = BrHXXRatio - 1.0;
10506 dBrHXXRatio2 = 0.0;
10507 } else if (fstate == 2){
10508 BrHXXRatio = (myNPbase->BrHgagaRatio());
10509 dBrHXXRatio1 = BrHXXRatio - 1.0;
10510 dBrHXXRatio2 = 0.0;
10511 } else if (fstate == 3){
10512 BrHXXRatio = (myNPbase->BrHbbRatio());
10513 dBrHXXRatio1 = BrHXXRatio - 1.0;
10514 dBrHXXRatio2 = 0.0;
10515 } else if (fstate == 4){
10516 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10517 dBrHXXRatio1 = BrHXXRatio - 1.0;
10518 dBrHXXRatio2 = 0.0;
10519 } else {
10520 throw std::runtime_error("STXS12_qqHll_pTV75_150 called with invalid argument for final state in fstate_i");
10521 }
10522
10523 //-- Production x Decay:
10524 if ((this->getModel()).isModelLinearized()){
10525 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10526 } else if((this->getModel()).isModelNPquadratic()){
10527 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10528 } else {
10529 return weight*(muProd)*(BrHXXRatio);
10530 }
10531
10532
10533}
10534
10535// -----------------------------------------------------------------------------
10536
10537//AG:STXS2024
10538STXS12_qqHll_pTV150_250_Nj0::STXS12_qqHll_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10539: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10540{
10541 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10542 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj0 called with a class whose parent is not NPbase");
10543
10544}
10545
10547{
10548 //-- Production:
10549 double weight = 1.0; //If normalized to the SM
10551 double muProd1 = muProd -1.0;
10552 double muProd2 = 0.0;
10553
10554 //-- Decay:
10555 double BrHXXRatio = 1.0;
10556 double dBrHXXRatio1 = 0.0;
10557 double dBrHXXRatio2 = 0.0;
10558 if (fstate==0){
10559 // Use for Cross-section [pb] with no Higgs-boson decay
10560 weight = 0.03223 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10561 } else if (fstate == 1){
10562 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10563 dBrHXXRatio1 = BrHXXRatio - 1.0;
10564 dBrHXXRatio2 = 0.0;
10565 } else if (fstate == 2){
10566 BrHXXRatio = (myNPbase->BrHgagaRatio());
10567 dBrHXXRatio1 = BrHXXRatio - 1.0;
10568 dBrHXXRatio2 = 0.0;
10569 } else if (fstate == 3){
10570 BrHXXRatio = (myNPbase->BrHbbRatio());
10571 dBrHXXRatio1 = BrHXXRatio - 1.0;
10572 dBrHXXRatio2 = 0.0;
10573 } else if (fstate == 4){
10574 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10575 dBrHXXRatio1 = BrHXXRatio - 1.0;
10576 dBrHXXRatio2 = 0.0;
10577 } else {
10578 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
10579 }
10580
10581 //-- Production x Decay:
10582 if ((this->getModel()).isModelLinearized()){
10583 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10584 } else if((this->getModel()).isModelNPquadratic()){
10585 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10586 } else {
10587 return weight*(muProd)*(BrHXXRatio);
10588 }
10589
10590}
10591
10592// -----------------------------------------------------------------------------
10593
10594STXS12_qqHll_pTV150_250_Nj1::STXS12_qqHll_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10595: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10596{
10597 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10598 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj1 called with a class whose parent is not NPbase");
10599
10600}
10601
10603{
10604 double BrHXXRatio = 1.0;
10605 if (fstate == 1){
10606 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10607 } else if (fstate == 2){
10608 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10609 } else if (fstate == 3){
10610 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10611 } else if (fstate == 4){
10612 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10613 } else {
10614 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
10615 }
10616
10617 if ((this->getModel()).isModelLinearized()) {
10618 return ((myNPbase->STXS12_qqHll_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
10619 } else {
10620 return (myNPbase->STXS12_qqHll_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
10621 }
10622}
10623
10624// -----------------------------------------------------------------------------
10625
10626STXS12_qqHll_pTV250_Inf::STXS12_qqHll_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10627: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10628{
10629 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10630 throw std::runtime_error("STXS12_qqHll_pTV250_Inf called with a class whose parent is not NPbase");
10631
10632}
10633
10635{
10636 double BrHXXRatio = 1.0;
10637 if (fstate == 1){
10638 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10639 } else if (fstate == 2){
10640 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10641 } else if (fstate == 3){
10642 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10643 } else if (fstate == 4){
10644 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10645 } else {
10646 throw std::runtime_error("STXS12_qqHll_pTV250_Inf called with invalid argument for final state in fstate_i");
10647 }
10648
10649 if ((this->getModel()).isModelLinearized()) {
10650 return ((myNPbase->STXS12_qqHll_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
10651 } else {
10652 return (myNPbase->STXS12_qqHll_pTV250_Inf(sqrt_s))*(BrHXXRatio);
10653 }
10654}
10655
10656
10657// -----------------------------------------------------------------------------
10658
10659//AG:STXS2024
10660STXS12_qqHll_pTV0_150::STXS12_qqHll_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10661: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10662{
10663 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10664 throw std::runtime_error("STXS12_qqHll_pTV0_150 called with a class whose parent is not NPbase");
10665
10666}
10667
10669{
10670 //-- Production:
10671 double weight = 1.0; //If normalized to the SM
10672 double muProd = myNPbase->STXS12_qqHll_pTV0_150(sqrt_s);
10673 double muProd1 = muProd -1.0;
10674 double muProd2 = 0.0;
10675
10676 //-- Decay:
10677 double BrHXXRatio = 1.0;
10678 double dBrHXXRatio1 = 0.0;
10679 double dBrHXXRatio2 = 0.0;
10680 if (fstate==0){
10681 // Use for Cross-section [pb] with no Higgs-boson decay
10682 weight = 0.19845 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10683 } else if (fstate == 1){
10684 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10685 dBrHXXRatio1 = BrHXXRatio - 1.0;
10686 dBrHXXRatio2 = 0.0;
10687 } else if (fstate == 2){
10688 BrHXXRatio = (myNPbase->BrHgagaRatio());
10689 dBrHXXRatio1 = BrHXXRatio - 1.0;
10690 dBrHXXRatio2 = 0.0;
10691 } else if (fstate == 3){
10692 BrHXXRatio = (myNPbase->BrHbbRatio());
10693 dBrHXXRatio1 = BrHXXRatio - 1.0;
10694 dBrHXXRatio2 = 0.0;
10695 } else if (fstate == 4){
10696 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10697 dBrHXXRatio1 = BrHXXRatio - 1.0;
10698 dBrHXXRatio2 = 0.0;
10699 } else {
10700 throw std::runtime_error("STXS12_qqHll_pTV0_150 called with invalid argument for final state in fstate_i");
10701 }
10702
10703 //-- Production x Decay:
10704 if ((this->getModel()).isModelLinearized()){
10705 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10706 } else if((this->getModel()).isModelNPquadratic()){
10707 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10708 } else {
10709 return weight*(muProd)*(BrHXXRatio);
10710 }
10711
10712}
10713
10714// -----------------------------------------------------------------------------
10715
10716//AG:STXS2024
10717STXS12_qqHll_pTV250_400::STXS12_qqHll_pTV250_400(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10718: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10719{
10720 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10721 throw std::runtime_error("STXS12_qqHll_pTV250_400 called with a class whose parent is not NPbase");
10722
10723}
10724
10726{
10727 //-- Production:
10728 double weight = 1.0; //If normalized to the SM
10729 double muProd = myNPbase->STXS12_qqHll_pTV250_400(sqrt_s);
10730 double muProd1 = muProd -1.0;
10731 double muProd2 = 0.0;
10732
10733 //-- Decay:
10734 double BrHXXRatio = 1.0;
10735 double dBrHXXRatio1 = 0.0;
10736 double dBrHXXRatio2 = 0.0;
10737 if (fstate==0){
10738 // Use for Cross-section [pb] with no Higgs-boson decay
10739 weight = 0.00715 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10740 } else if (fstate == 1){
10741 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10742 dBrHXXRatio1 = BrHXXRatio - 1.0;
10743 dBrHXXRatio2 = 0.0;
10744 } else if (fstate == 2){
10745 BrHXXRatio = (myNPbase->BrHgagaRatio());
10746 dBrHXXRatio1 = BrHXXRatio - 1.0;
10747 dBrHXXRatio2 = 0.0;
10748 } else if (fstate == 3){
10749 BrHXXRatio = (myNPbase->BrHbbRatio());
10750 dBrHXXRatio1 = BrHXXRatio - 1.0;
10751 dBrHXXRatio2 = 0.0;
10752 } else if (fstate == 4){
10753 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10754 dBrHXXRatio1 = BrHXXRatio - 1.0;
10755 dBrHXXRatio2 = 0.0;
10756 } else {
10757 throw std::runtime_error("STXS12_qqHll_pTV250_400 called with invalid argument for final state in fstate_i");
10758 }
10759
10760 //-- Production x Decay:
10761 if ((this->getModel()).isModelLinearized()){
10762 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10763 } else if((this->getModel()).isModelNPquadratic()){
10764 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10765 } else {
10766 return weight*(muProd)*(BrHXXRatio);
10767 }
10768
10769}
10770
10771// -----------------------------------------------------------------------------
10772
10773//AG:STXS2024
10774STXS12_qqHll_pTV400_Inf::STXS12_qqHll_pTV400_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10775: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10776{
10777 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10778 throw std::runtime_error("STXS12_qqHll_pTV400_Inf called with a class whose parent is not NPbase");
10779
10780}
10781
10783{
10784 //-- Production:
10785 double weight = 1.0; //If normalized to the SM
10786 double muProd = myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s);
10787 double muProd1 = muProd -1.0;
10788 double muProd2 = 0.0;
10789
10790 //-- Decay:
10791 double BrHXXRatio = 1.0;
10792 double dBrHXXRatio1 = 0.0;
10793 double dBrHXXRatio2 = 0.0;
10794 if (fstate==0){
10795 // Use for Cross-section [pb] with no Higgs-boson decay
10796 weight = 0.00126 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10797 } else if (fstate == 1){
10798 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10799 dBrHXXRatio1 = BrHXXRatio - 1.0;
10800 dBrHXXRatio2 = 0.0;
10801 } else if (fstate == 2){
10802 BrHXXRatio = (myNPbase->BrHgagaRatio());
10803 dBrHXXRatio1 = BrHXXRatio - 1.0;
10804 dBrHXXRatio2 = 0.0;
10805 } else if (fstate == 3){
10806 BrHXXRatio = (myNPbase->BrHbbRatio());
10807 dBrHXXRatio1 = BrHXXRatio - 1.0;
10808 dBrHXXRatio2 = 0.0;
10809 } else if (fstate == 4){
10810 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10811 dBrHXXRatio1 = BrHXXRatio - 1.0;
10812 dBrHXXRatio2 = 0.0;
10813 } else {
10814 throw std::runtime_error("STXS12_qqHll_pTV400_Inf called with invalid argument for final state in fstate_i");
10815 }
10816
10817 //-- Production x Decay:
10818 if ((this->getModel()).isModelLinearized()){
10819 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10820 } else if((this->getModel()).isModelNPquadratic()){
10821 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10822 } else {
10823 return weight*(muProd)*(BrHXXRatio);
10824 }
10825
10826
10827}
10828
10829// -----------------------------------------------------------------------------
10830
10831//AG:STXS2024
10832STXS12_qqHll_pTV150_Inf::STXS12_qqHll_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10833: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10834{
10835 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10836 throw std::runtime_error("STXS12_qqHll_pTV150_Inf called with a class whose parent is not NPbase");
10837
10838}
10839
10841{
10842 //-- Production:
10843 double weight = 1.0; //If normalized to the SM
10844 //Since adding bins, include partial weigths of SM_predictions
10845 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10846 double muProd = (0.03223*(myNPbase->STXS12_qqHll_pTV150_250_Nj0(sqrt_s))
10848 + 0.00126*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)) )/(0.03223+0.00715+0.00126);
10849 double muProd1 = (0.03223*(myNPbase->STXS12_qqHll_pTV150_250_Nj0(sqrt_s)-1.0)
10850 + 0.00715*(myNPbase->STXS12_qqHll_pTV250_400(sqrt_s)-1.0)
10851 + 0.00126*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)-1.0) )/(0.03223+0.00715+0.00126);
10852 double muProd2 = 0.0;
10853
10854 //-- Decay:
10855 double BrHXXRatio = 1.0;
10856 double dBrHXXRatio1 = 0.0;
10857 double dBrHXXRatio2 = 0.0;
10858 if (fstate==0){
10859 weight = 1.0 ;
10860 } else if (fstate == 1){
10861 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10862 dBrHXXRatio1 = BrHXXRatio - 1.0;
10863 dBrHXXRatio2 = 0.0;
10864 } else if (fstate == 2){
10865 BrHXXRatio = (myNPbase->BrHgagaRatio());
10866 dBrHXXRatio1 = BrHXXRatio - 1.0;
10867 dBrHXXRatio2 = 0.0;
10868 } else if (fstate == 3){
10869 BrHXXRatio = (myNPbase->BrHbbRatio());
10870 dBrHXXRatio1 = BrHXXRatio - 1.0;
10871 dBrHXXRatio2 = 0.0;
10872 } else if (fstate == 4){
10873 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10874 dBrHXXRatio1 = BrHXXRatio - 1.0;
10875 dBrHXXRatio2 = 0.0;
10876 } else {
10877 throw std::runtime_error("STXS12_qqHll_pTV150_Inf called with invalid argument for final state in fstate_i");
10878 }
10879
10880 //-- Production x Decay:
10881 if ((this->getModel()).isModelLinearized()){
10882 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10883 } else if((this->getModel()).isModelNPquadratic()){
10884 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10885 } else {
10886 return weight*(muProd)*(BrHXXRatio);
10887 }
10888
10889
10890}
10891
10892// -----------------------------------------------------------------------------
10893
10894//AG:STXS2024
10895STXS12_VHlep::STXS12_VHlep(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10896: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10897{
10898 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10899 throw std::runtime_error("STXS12_VHlep called with a class whose parent is not NPbase");
10900
10901}
10902
10904{
10905 //-- Production:
10906 double weight = 1.0; //If normalized to the SM
10907 //Since adding bins, include partial weigths of SM_predictions
10908 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10909 double muProd = ( 0.71256*myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)
10918 /(0.71256 + 0.06739 + 0.03943 + 0.01127 + 0.00339 + 0.07934 + 0.03525 + 0.00746 + 0.00043);
10919 double muProd1 = ( 0.71256*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)-1.0)
10920 + 0.06739*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s)-1.0)
10922 + 0.01127*(myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0)
10923 + 0.00339*(myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s)-1.0)
10924 + 0.07934*(myNPbase->STXS12_qqHll_pTV0_150(sqrt_s) -1.0)
10926 + 0.00746*(myNPbase->STXS12_qqHll_pTV250_400(sqrt_s)-1.0)
10927 + 0.00043*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)-1.0) )
10928 /(0.71256 + 0.06739 + 0.03943 + 0.01127 + 0.00339 + 0.07934 + 0.03525 + 0.00746 + 0.00043);
10929 double muProd2 = 0.0;
10930
10931 //-- Decay:
10932 double BrHXXRatio = 1.0;
10933 double dBrHXXRatio1 = 0.0;
10934 double dBrHXXRatio2 = 0.0;
10935 if (fstate==0){
10936 weight = 1.0;
10937 } else if (fstate == 1){
10938 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10939 dBrHXXRatio1 = BrHXXRatio - 1.0;
10940 dBrHXXRatio2 = 0.0;
10941 } else if (fstate == 2){
10942 BrHXXRatio = (myNPbase->BrHgagaRatio());
10943 dBrHXXRatio1 = BrHXXRatio - 1.0;
10944 dBrHXXRatio2 = 0.0;
10945 } else if (fstate == 3){
10946 BrHXXRatio = (myNPbase->BrHbbRatio());
10947 dBrHXXRatio1 = BrHXXRatio - 1.0;
10948 dBrHXXRatio2 = 0.0;
10949 } else if (fstate == 4){
10950 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10951 dBrHXXRatio1 = BrHXXRatio - 1.0;
10952 dBrHXXRatio2 = 0.0;
10953 } else if (fstate == 5){
10954 BrHXXRatio = (myNPbase->BrHtautauRatio());
10955 dBrHXXRatio1 = BrHXXRatio - 1.0;
10956 dBrHXXRatio2 = 0.0;
10957 } else if (fstate == 6){
10958 BrHXXRatio = (myNPbase->BrHWWRatio());
10959 dBrHXXRatio1 = BrHXXRatio - 1.0;
10960 dBrHXXRatio2 = 0.0;
10961 } else if (fstate == 7){
10962 BrHXXRatio = (myNPbase->BrHZZRatio());
10963 dBrHXXRatio1 = BrHXXRatio - 1.0;
10964 dBrHXXRatio2 = 0.0;
10965 } else {
10966 throw std::runtime_error("STXS12_VHlep called with invalid argument for final state in fstate_i");
10967 }
10968
10969 //-- Production x Decay:
10970 if ((this->getModel()).isModelLinearized()){
10971 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10972 } else if((this->getModel()).isModelNPquadratic()){
10973 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10974 } else {
10975 return weight*(muProd)*(BrHXXRatio);
10976 }
10977
10978
10979}
10980
10981// -----------------------------------------------------------------------------
10982
10983//AG:STXS2024
10984STXS12_ttH_pTH0_60::STXS12_ttH_pTH0_60(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10985: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10986{
10987 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10988 throw std::runtime_error("STXS12_ttH_pTH0_60 called with a class whose parent is not NPbase");
10989
10990}
10991
10993{
10994 //-- Production:
10995 double weight = 1.0; //If normalized to the SM
10996 double muProd = myNPbase->STXS12_ttH_pTH0_60(sqrt_s) ;
10997 double muProd1 = muProd -1.0;
10998 double muProd2 = 0.0;
10999
11000 //-- Decay:
11001 double BrHXXRatio = 1.0;
11002 double dBrHXXRatio1 = 0.0;
11003 double dBrHXXRatio2 = 0.0;
11004 if (fstate==0){
11005 // Use for Cross-section [pb] with no Higgs-boson decay
11006 weight = 0.11821; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11007 } else if (fstate == 1){
11008 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11009 dBrHXXRatio1 = BrHXXRatio - 1.0;
11010 dBrHXXRatio2 = 0.0;
11011 } else if (fstate == 2){
11012 BrHXXRatio = (myNPbase->BrHgagaRatio());
11013 dBrHXXRatio1 = BrHXXRatio - 1.0;
11014 dBrHXXRatio2 = 0.0;
11015 } else if (fstate == 3){
11016 BrHXXRatio = (myNPbase->BrHbbRatio());
11017 dBrHXXRatio1 = BrHXXRatio - 1.0;
11018 dBrHXXRatio2 = 0.0;
11019 } else if (fstate == 4){
11020 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11021 dBrHXXRatio1 = BrHXXRatio - 1.0;
11022 dBrHXXRatio2 = 0.0;
11023 } else {
11024 throw std::runtime_error("STXS12_ttH_pTH0_60 called with invalid argument for final state in fstate_i");
11025 }
11026
11027 //-- Production x Decay:
11028 if ((this->getModel()).isModelLinearized()){
11029 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11030 } else if((this->getModel()).isModelNPquadratic()){
11031 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11032 } else {
11033 return weight*(muProd)*(BrHXXRatio);
11034 }
11035
11036
11037}
11038
11039// -----------------------------------------------------------------------------
11040
11041//AG:STXS2024
11042STXS12_ttH_pTH60_120::STXS12_ttH_pTH60_120(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11043: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11044{
11045 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11046 throw std::runtime_error("STXS12_ttH_pTH60_120 called with a class whose parent is not NPbase");
11047
11048}
11049
11051{
11052 //-- Production:
11053 double weight = 1.0; //If normalized to the SM
11054 double muProd = myNPbase->STXS12_ttH_pTH60_120(sqrt_s) ;
11055 double muProd1 = muProd -1.0;
11056 double muProd2 = 0.0;
11057
11058 //-- Decay:
11059 double BrHXXRatio = 1.0;
11060 double dBrHXXRatio1 = 0.0;
11061 double dBrHXXRatio2 = 0.0;
11062 if (fstate==0){
11063 // Use for Cross-section [pb] with no Higgs-boson decay
11064 weight = 0.17813; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11065 } else if (fstate == 1){
11066 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11067 dBrHXXRatio1 = BrHXXRatio - 1.0;
11068 dBrHXXRatio2 = 0.0;
11069 } else if (fstate == 2){
11070 BrHXXRatio = (myNPbase->BrHgagaRatio());
11071 dBrHXXRatio1 = BrHXXRatio - 1.0;
11072 dBrHXXRatio2 = 0.0;
11073 } else if (fstate == 3){
11074 BrHXXRatio = (myNPbase->BrHbbRatio());
11075 dBrHXXRatio1 = BrHXXRatio - 1.0;
11076 dBrHXXRatio2 = 0.0;
11077 } else if (fstate == 4){
11078 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11079 dBrHXXRatio1 = BrHXXRatio - 1.0;
11080 dBrHXXRatio2 = 0.0;
11081 } else {
11082 throw std::runtime_error("STXS12_ttH_pTH60_120 called with invalid argument for final state in fstate_i");
11083 }
11084
11085 //-- Production x Decay:
11086 if ((this->getModel()).isModelLinearized()){
11087 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11088 } else if((this->getModel()).isModelNPquadratic()){
11089 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11090 } else {
11091 return weight*(muProd)*(BrHXXRatio);
11092 }
11093
11094}
11095
11096// -----------------------------------------------------------------------------
11097
11098//AG:STXS2024
11099STXS12_ttH_pTH0_120::STXS12_ttH_pTH0_120(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11100: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11101{
11102 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11103 throw std::runtime_error("STXS12_ttH_pTH0_120 called with a class whose parent is not NPbase");
11104
11105}
11106
11108{
11109 //-- Production:
11110 double weight = 1.0; //If normalized to the SM
11111 //Since adding bins, include partial weigths of SM_predictions
11112 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11113 double muProd = ( 0.11821*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s) )
11114 + 0.17813*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s) ) )/(0.11821+0.17813);
11115 double muProd1 = ( 0.11821*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s) -1.0)
11116 + 0.17813*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s)-1.0 ) )/(0.11821+0.17813);;
11117 double muProd2 = 0.0;
11118
11119 //-- Decay:
11120 double BrHXXRatio = 1.0;
11121 double dBrHXXRatio1 = 0.0;
11122 double dBrHXXRatio2 = 0.0;
11123 if (fstate==0){
11124 // Use for Cross-section [pb] with no Higgs-boson decay
11125 weight = 0.17813; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11126 } else if (fstate == 1){
11127 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11128 dBrHXXRatio1 = BrHXXRatio - 1.0;
11129 dBrHXXRatio2 = 0.0;
11130 } else if (fstate == 2){
11131 BrHXXRatio = (myNPbase->BrHgagaRatio());
11132 dBrHXXRatio1 = BrHXXRatio - 1.0;
11133 dBrHXXRatio2 = 0.0;
11134 } else if (fstate == 3){
11135 BrHXXRatio = (myNPbase->BrHbbRatio());
11136 dBrHXXRatio1 = BrHXXRatio - 1.0;
11137 dBrHXXRatio2 = 0.0;
11138 } else if (fstate == 4){
11139 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11140 dBrHXXRatio1 = BrHXXRatio - 1.0;
11141 dBrHXXRatio2 = 0.0;
11142 } else {
11143 throw std::runtime_error("STXS12_ttH_pTH0_120 called with invalid argument for final state in fstate_i");
11144 }
11145
11146 //-- Production x Decay:
11147 if ((this->getModel()).isModelLinearized()){
11148 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11149 } else if((this->getModel()).isModelNPquadratic()){
11150 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11151 } else {
11152 return weight*(muProd)*(BrHXXRatio);
11153 }
11154
11155}
11156
11157// -----------------------------------------------------------------------------
11158
11159//AG:STXS2024
11160STXS12_ttH_pTH120_200::STXS12_ttH_pTH120_200(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11161: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11162{
11163 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11164 throw std::runtime_error("STXS12_ttH_pTH120_200 called with a class whose parent is not NPbase");
11165
11166}
11167
11169{
11170 //-- Production:
11171 double weight = 1.0; //If normalized to the SM
11172 double muProd = myNPbase->STXS12_ttH_pTH120_200(sqrt_s) ;
11173 double muProd1 = muProd -1.0;
11174 double muProd2 = 0.0;
11175
11176 //-- Decay:
11177 double BrHXXRatio = 1.0;
11178 double dBrHXXRatio1 = 0.0;
11179 double dBrHXXRatio2 = 0.0;
11180 if (fstate==0){
11181 // Use for Cross-section [pb] with no Higgs-boson decay
11182 weight = 0.12647; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11183 } else if (fstate == 1){
11184 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11185 dBrHXXRatio1 = BrHXXRatio - 1.0;
11186 dBrHXXRatio2 = 0.0;
11187 } else if (fstate == 2){
11188 BrHXXRatio = (myNPbase->BrHgagaRatio());
11189 dBrHXXRatio1 = BrHXXRatio - 1.0;
11190 dBrHXXRatio2 = 0.0;
11191 } else if (fstate == 3){
11192 BrHXXRatio = (myNPbase->BrHbbRatio());
11193 dBrHXXRatio1 = BrHXXRatio - 1.0;
11194 dBrHXXRatio2 = 0.0;
11195 } else if (fstate == 4){
11196 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11197 dBrHXXRatio1 = BrHXXRatio - 1.0;
11198 dBrHXXRatio2 = 0.0;
11199 } else {
11200 throw std::runtime_error("STXS12_ttH_pTH120_200 called with invalid argument for final state in fstate_i");
11201 }
11202
11203 //-- Production x Decay:
11204 if ((this->getModel()).isModelLinearized()){
11205 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11206 } else if((this->getModel()).isModelNPquadratic()){
11207 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11208 } else {
11209 return weight*(muProd)*(BrHXXRatio);
11210 }
11211
11212}
11213
11214// -----------------------------------------------------------------------------
11215
11216//AG:STXS2024
11217STXS12_ttH_pTH200_300::STXS12_ttH_pTH200_300(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11218: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11219{
11220 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11221 throw std::runtime_error("STXS12_ttH_pTH200_300 called with a class whose parent is not NPbase");
11222
11223}
11224
11226{
11227 //-- Production:
11228 double weight = 1.0; //If normalized to the SM
11229 double muProd = myNPbase->STXS12_ttH_pTH200_300(sqrt_s) ;
11230 double muProd1 = muProd -1.0;
11231 double muProd2 = 0.0;
11232
11233 //-- Decay:
11234 double BrHXXRatio = 1.0;
11235 double dBrHXXRatio1 = 0.0;
11236 double dBrHXXRatio2 = 0.0;
11237 if (fstate==0){
11238 // Use for Cross-section [pb] with no Higgs-boson decay
11239 weight = 0.05263; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11240 } else if (fstate == 1){
11241 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11242 dBrHXXRatio1 = BrHXXRatio - 1.0;
11243 dBrHXXRatio2 = 0.0;
11244 } else if (fstate == 2){
11245 BrHXXRatio = (myNPbase->BrHgagaRatio());
11246 dBrHXXRatio1 = BrHXXRatio - 1.0;
11247 dBrHXXRatio2 = 0.0;
11248 } else if (fstate == 3){
11249 BrHXXRatio = (myNPbase->BrHbbRatio());
11250 dBrHXXRatio1 = BrHXXRatio - 1.0;
11251 dBrHXXRatio2 = 0.0;
11252 } else if (fstate == 4){
11253 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11254 dBrHXXRatio1 = BrHXXRatio - 1.0;
11255 dBrHXXRatio2 = 0.0;
11256 } else {
11257 throw std::runtime_error("STXS12_ttH_pTH200_300 called with invalid argument for final state in fstate_i");
11258 }
11259
11260 //-- Production x Decay:
11261 if ((this->getModel()).isModelLinearized()){
11262 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11263 } else if((this->getModel()).isModelNPquadratic()){
11264 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11265 } else {
11266 return weight*(muProd)*(BrHXXRatio);
11267 }
11268
11269}
11270
11271// -----------------------------------------------------------------------------
11272
11273STXS12_ttH_pTH300_Inf::STXS12_ttH_pTH300_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11274: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11275{
11276 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11277 throw std::runtime_error("STXS12_ttH_pTH300_Inf called with a class whose parent is not NPbase");
11278
11279}
11280
11282{
11283 //-- Production:
11284 double weight = 1.0; //If normalized to the SM
11285 double muProd = myNPbase->STXS12_ttH_pTH300_Inf(sqrt_s) ;
11286 double muProd1 = muProd -1.0;
11287 double muProd2 = 0.0;
11288
11289 //-- Decay:
11290 double BrHXXRatio = 1.0;
11291 double dBrHXXRatio1 = 0.0;
11292 double dBrHXXRatio2 = 0.0;
11293 if (fstate==0){
11294 // Use for Cross-section [pb] with no Higgs-boson decay
11295 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11296 } else if (fstate == 1){
11297 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11298 dBrHXXRatio1 = BrHXXRatio - 1.0;
11299 dBrHXXRatio2 = 0.0;
11300 } else if (fstate == 2){
11301 BrHXXRatio = (myNPbase->BrHgagaRatio());
11302 dBrHXXRatio1 = BrHXXRatio - 1.0;
11303 dBrHXXRatio2 = 0.0;
11304 } else if (fstate == 3){
11305 BrHXXRatio = (myNPbase->BrHbbRatio());
11306 dBrHXXRatio1 = BrHXXRatio - 1.0;
11307 dBrHXXRatio2 = 0.0;
11308 } else if (fstate == 4){
11309 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11310 dBrHXXRatio1 = BrHXXRatio - 1.0;
11311 dBrHXXRatio2 = 0.0;
11312 } else {
11313 throw std::runtime_error("STXS12_ttH_pTH300_Inf called with invalid argument for final state in fstate_i");
11314 }
11315
11316 //-- Production x Decay:
11317 if ((this->getModel()).isModelLinearized()){
11318 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11319 } else if((this->getModel()).isModelNPquadratic()){
11320 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11321 } else {
11322 return weight*(muProd)*(BrHXXRatio);
11323 }
11324
11325
11326}
11327
11328// -----------------------------------------------------------------------------
11329
11330//AG:STXS2024
11331STXS12_ttH_pTH300_450::STXS12_ttH_pTH300_450(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11332: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11333{
11334 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11335 throw std::runtime_error("STXS12_ttH_pTH300_450 called with a class whose parent is not NPbase");
11336
11337}
11338
11340{
11341 //-- Production:
11342 double weight = 1.0; //If normalized to the SM
11343 double muProd = myNPbase->STXS12_ttH_pTH300_450(sqrt_s);
11344 double muProd1 = muProd -1.0;
11345 double muProd2 = 0.0;
11346
11347 //-- Decay:
11348 double BrHXXRatio = 1.0;
11349 double dBrHXXRatio1 = 0.0;
11350 double dBrHXXRatio2 = 0.0;
11351 if (fstate==0){
11352 // Use for Cross-section [pb] with no Higgs-boson decay
11353 weight = 0.01903; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11354 } else if (fstate == 1){
11355 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11356 dBrHXXRatio1 = BrHXXRatio - 1.0;
11357 dBrHXXRatio2 = 0.0;
11358 } else if (fstate == 2){
11359 BrHXXRatio = (myNPbase->BrHgagaRatio());
11360 dBrHXXRatio1 = BrHXXRatio - 1.0;
11361 dBrHXXRatio2 = 0.0;
11362 } else if (fstate == 3){
11363 BrHXXRatio = (myNPbase->BrHbbRatio());
11364 dBrHXXRatio1 = BrHXXRatio - 1.0;
11365 dBrHXXRatio2 = 0.0;
11366 } else if (fstate == 4){
11367 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11368 dBrHXXRatio1 = BrHXXRatio - 1.0;
11369 dBrHXXRatio2 = 0.0;
11370 } else if (fstate == 5){
11371 BrHXXRatio = (myNPbase->BrHtautauRatio());
11372 dBrHXXRatio1 = BrHXXRatio - 1.0;
11373 dBrHXXRatio2 = 0.0;
11374 } else {
11375 throw std::runtime_error("STXS12_ttH_pTH300_450 called with invalid argument for final state in fstate_i");
11376 }
11377
11378 //-- Production x Decay:
11379 if ((this->getModel()).isModelLinearized()){
11380 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11381 } else if((this->getModel()).isModelNPquadratic()){
11382 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11383 } else {
11384 return weight*(muProd)*(BrHXXRatio);
11385 }
11386
11387}
11388// -----------------------------------------------------------------------------
11389
11390//AG:STXS2024
11391STXS12_ttH_pTH450_Inf::STXS12_ttH_pTH450_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11392: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11393{
11394 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11395 throw std::runtime_error("STXS12_ttH_pTH450_Inf called with a class whose parent is not NPbase");
11396
11397}
11398
11400{
11401 //-- Production:
11402 double weight = 1.0; //If normalized to the SM
11403 double muProd = myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s);
11404 double muProd1 = muProd -1.0;
11405 double muProd2 = 0.0;
11406
11407 //-- Decay:
11408 double BrHXXRatio = 1.0;
11409 double dBrHXXRatio1 = 0.0;
11410 double dBrHXXRatio2 = 0.0;
11411 if (fstate==0){
11412 // Use for Cross-section [pb] with no Higgs-boson decay
11413 weight = 0.00538; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11414 } else if (fstate == 1){
11415 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11416 dBrHXXRatio1 = BrHXXRatio - 1.0;
11417 dBrHXXRatio2 = 0.0;
11418 } else if (fstate == 2){
11419 BrHXXRatio = (myNPbase->BrHgagaRatio());
11420 dBrHXXRatio1 = BrHXXRatio - 1.0;
11421 dBrHXXRatio2 = 0.0;
11422 } else if (fstate == 3){
11423 BrHXXRatio = (myNPbase->BrHbbRatio());
11424 dBrHXXRatio1 = BrHXXRatio - 1.0;
11425 dBrHXXRatio2 = 0.0;
11426 } else if (fstate == 4){
11427 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11428 dBrHXXRatio1 = BrHXXRatio - 1.0;
11429 dBrHXXRatio2 = 0.0;
11430 } else if (fstate == 5){
11431 BrHXXRatio = (myNPbase->BrHtautauRatio());
11432 dBrHXXRatio1 = BrHXXRatio - 1.0;
11433 dBrHXXRatio2 = 0.0;
11434 } else {
11435 throw std::runtime_error("STXS12_ttH_pTH450_Inf called with invalid argument for final state in fstate_i");
11436 }
11437
11438 //-- Production x Decay:
11439 if ((this->getModel()).isModelLinearized()){
11440 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11441 } else if((this->getModel()).isModelNPquadratic()){
11442 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11443 } else {
11444 return weight*(muProd)*(BrHXXRatio);
11445 }
11446
11447}
11448
11449// -----------------------------------------------------------------------------
11450
11451//AG:STXS2024
11452STXS12_ttH_pTH300_Inf_add::STXS12_ttH_pTH300_Inf_add(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11453: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11454{
11455 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11456 throw std::runtime_error("STXS12_ttH_pTH300_Inf_add called with a class whose parent is not NPbase");
11457
11458}
11459
11461{
11462 //-- Production:
11463 double weight = 1.0; //If normalized to the SM
11464 //Since adding bins, include partial weigths of SM_predictions
11465 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11466 double muProd = (0.01903*myNPbase->STXS12_ttH_pTH300_450(sqrt_s)
11467 + 0.00538*myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)) / (0.01903+0.00538);
11468 double muProd1 = (0.01903*(myNPbase->STXS12_ttH_pTH300_450(sqrt_s)-1.0)
11469 + 0.00538*(myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)-1.0)) / (0.01903+0.00538);
11470 double muProd2 = 0.0;
11471
11472 //-- Decay:
11473 double BrHXXRatio = 1.0;
11474 double dBrHXXRatio1 = 0.0;
11475 double dBrHXXRatio2 = 0.0;
11476 if (fstate==0){
11477 // Use for Cross-section [pb] with no Higgs-boson decay
11478 weight = 0.00538; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11479 } else if (fstate == 1){
11480 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11481 dBrHXXRatio1 = BrHXXRatio - 1.0;
11482 dBrHXXRatio2 = 0.0;
11483 } else if (fstate == 2){
11484 BrHXXRatio = (myNPbase->BrHgagaRatio());
11485 dBrHXXRatio1 = BrHXXRatio - 1.0;
11486 dBrHXXRatio2 = 0.0;
11487 } else if (fstate == 3){
11488 BrHXXRatio = (myNPbase->BrHbbRatio());
11489 dBrHXXRatio1 = BrHXXRatio - 1.0;
11490 dBrHXXRatio2 = 0.0;
11491 } else if (fstate == 4){
11492 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11493 dBrHXXRatio1 = BrHXXRatio - 1.0;
11494 dBrHXXRatio2 = 0.0;
11495 } else if (fstate == 5){
11496 BrHXXRatio = (myNPbase->BrHtautauRatio());
11497 dBrHXXRatio1 = BrHXXRatio - 1.0;
11498 dBrHXXRatio2 = 0.0;
11499 } else {
11500 throw std::runtime_error("STXS12_ttH_pTH300_Inf_add called with invalid argument for final state in fstate_i");
11501 }
11502
11503 //-- Production x Decay:
11504 if ((this->getModel()).isModelLinearized()){
11505 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11506 } else if((this->getModel()).isModelNPquadratic()){
11507 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11508 } else {
11509 return weight*(muProd)*(BrHXXRatio);
11510 }
11511
11512}
11513
11514// -----------------------------------------------------------------------------
11515
11516//AG:STXS2024
11517STXS12_ttH::STXS12_ttH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11518: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11519{
11520 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11521 throw std::runtime_error("STXS12_ttH called with a class whose parent is not NPbase");
11522
11523}
11524
11526{
11527 //-- Production:
11528 double weight = 1.0; //If normalized to the SM
11529 //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11530 //Since adding bins, include partial weigths (SM_predictions)
11531 double muProd = ( 0.09779*myNPbase->STXS12_ttH_pTH0_60(sqrt_s)
11536 + 0.00060*myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s) ) /(0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 );
11537 double muProd1 = ( 0.09779*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s)-1.0)
11538 + 0.13884*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s)-1.0)
11539 + 0.05439*(myNPbase->STXS12_ttH_pTH120_200(sqrt_s)-1.0)
11540 + 0.05303*(myNPbase->STXS12_ttH_pTH200_300(sqrt_s)-1.0)
11541 + 0.00498*(myNPbase->STXS12_ttH_pTH300_450(sqrt_s)-1.0)
11542 + 0.00060*(myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)-1.0) ) /(0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 );
11543 double muProd2 = 0.0;
11544
11545 //-- Decay:
11546 double BrHXXRatio = 1.0;
11547 double dBrHXXRatio1 = 0.0;
11548 double dBrHXXRatio2 = 0.0;
11549 if (fstate==0){
11550 weight = 1.0;
11551 } else if (fstate == 1){
11552 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11553 dBrHXXRatio1 = BrHXXRatio - 1.0;
11554 dBrHXXRatio2 = 0.0;
11555 } else if (fstate == 2){
11556 BrHXXRatio = (myNPbase->BrHgagaRatio());
11557 dBrHXXRatio1 = BrHXXRatio - 1.0;
11558 dBrHXXRatio2 = 0.0;
11559 } else if (fstate == 3){
11560 BrHXXRatio = (myNPbase->BrHbbRatio());
11561 dBrHXXRatio1 = BrHXXRatio - 1.0;
11562 dBrHXXRatio2 = 0.0;
11563 } else if (fstate == 4){
11564 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11565 dBrHXXRatio1 = BrHXXRatio - 1.0;
11566 dBrHXXRatio2 = 0.0;
11567 } else if (fstate == 5){
11568 BrHXXRatio = (myNPbase->BrHtautauRatio());
11569 dBrHXXRatio1 = BrHXXRatio - 1.0;
11570 dBrHXXRatio2 = 0.0;
11571 } else if (fstate == 6){
11572 BrHXXRatio = (myNPbase->BrHWWRatio());
11573 dBrHXXRatio1 = BrHXXRatio - 1.0;
11574 dBrHXXRatio2 = 0.0;
11575 } else if (fstate == 7){
11576 BrHXXRatio = (myNPbase->BrHZZRatio());
11577 dBrHXXRatio1 = BrHXXRatio - 1.0;
11578 dBrHXXRatio2 = 0.0;
11579 } else {
11580 throw std::runtime_error("STXS12_ttH called with invalid argument for final state in fstate_i");
11581 }
11582
11583 //-- Production x Decay:
11584 if ((this->getModel()).isModelLinearized()){
11585 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11586 } else if((this->getModel()).isModelNPquadratic()){
11587 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11588 } else {
11589 return weight*(muProd)*(BrHXXRatio);
11590 }
11591
11592}
11593
11594// -----------------------------------------------------------------------------
11595
11596//AG:STXS2024
11597STXS12_tH::STXS12_tH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11598: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11599{
11600 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11601 throw std::runtime_error("STXS12_tH called with a class whose parent is not NPbase");
11602
11603}
11604
11605double STXS12_tH::computeThValue() //AG:modified
11606{
11607 //-- Production:
11608 double weight = 1.0; //If normalized to the SM
11609 double muProd = myNPbase->STXS12_tH(sqrt_s);
11610 double muProd1 = muProd -1.0;
11611 double muProd2 = 0.0;
11612
11613 //-- Decay:
11614 double BrHXXRatio = 1.0;
11615 double dBrHXXRatio1 = 0.0;
11616 double dBrHXXRatio2 = 0.0;
11617 if (fstate==0){
11618 // Use for Cross-section [pb] with no Higgs-boson decay
11619 weight = 0.08207; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11620 } else if (fstate == 1){
11621 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11622 dBrHXXRatio1 = BrHXXRatio - 1.0;
11623 dBrHXXRatio2 = 0.0;
11624 } else if (fstate == 2){
11625 BrHXXRatio = (myNPbase->BrHgagaRatio());
11626 dBrHXXRatio1 = BrHXXRatio - 1.0;
11627 dBrHXXRatio2 = 0.0;
11628 } else if (fstate == 3){
11629 BrHXXRatio = (myNPbase->BrHbbRatio());
11630 dBrHXXRatio1 = BrHXXRatio - 1.0;
11631 dBrHXXRatio2 = 0.0;
11632 } else if (fstate == 4){
11633 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11634 dBrHXXRatio1 = BrHXXRatio - 1.0;
11635 dBrHXXRatio2 = 0.0;
11636 } else if (fstate == 5){
11637 BrHXXRatio = (myNPbase->BrHtautauRatio());
11638 dBrHXXRatio1 = BrHXXRatio - 1.0;
11639 dBrHXXRatio2 = 0.0;
11640 } else {
11641 throw std::runtime_error("STXS12_tH called with invalid argument for final state in fstate_i");
11642 }
11643
11644 //-- Production x Decay:
11645 if ((this->getModel()).isModelLinearized()){
11646 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11647 } else if((this->getModel()).isModelNPquadratic()){
11648 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11649 } else {
11650 return weight*(muProd)*(BrHXXRatio);
11651 }
11652
11653
11654}
11655
11656// -----------------------------------------------------------------------------
11657
11658
11659//-----------------------------------------------------------------------------------------
11660//-- Special Hadron collider signal strengths with separate full TH unc U(prod x decay) ---
11661//-----------------------------------------------------------------------------------------
11662
11663
11664muTHUggHgaga::muTHUggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11665: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11666{
11667 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11668 throw std::runtime_error("muTHUggHgaga called with a class whose parent is not NPbase");
11669}
11670
11672{
11673 return myNPbase->muTHUggHgaga(sqrt_s);
11674}
11675
11676
11677muTHUVBFHgaga::muTHUVBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11678: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11679{
11680 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11681 throw std::runtime_error("muTHUVBFHgaga called with a class whose parent is not NPbase");
11682}
11683
11685{
11686 return myNPbase->muTHUVBFHgaga(sqrt_s);
11687}
11688
11689muTHUZHgaga::muTHUZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11690: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11691{
11692 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11693 throw std::runtime_error("muTHUZHgaga called with a class whose parent is not NPbase");
11694}
11695
11697{
11698 return myNPbase->muTHUZHgaga(sqrt_s);
11699}
11700
11701muTHUWHgaga::muTHUWHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11702: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11703{
11704 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11705 throw std::runtime_error("muTHUWHgaga called with a class whose parent is not NPbase");
11706}
11707
11709{
11710 return myNPbase->muTHUWHgaga(sqrt_s);
11711}
11712
11713muTHUVHgaga::muTHUVHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11714: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11715{
11716 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11717 throw std::runtime_error("muTHUVHgaga called with a class whose parent is not NPbase");
11718}
11719
11721{
11722 return myNPbase->muTHUVHgaga(sqrt_s);
11723}
11724
11725muTHUttHgaga::muTHUttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11726: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11727{
11728 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11729 throw std::runtime_error("muTHUttHgaga called with a class whose parent is not NPbase");
11730}
11731
11733{
11734 return myNPbase->muTHUttHgaga(sqrt_s);
11735}
11736
11737muTHUggHZga::muTHUggHZga(const StandardModel& SM_i, const double sqrt_s_i)
11738: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11739{
11740 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11741 throw std::runtime_error("muTHUggHZga called with a class whose parent is not NPbase");
11742}
11743
11745{
11746 return myNPbase->muTHUggHZga(sqrt_s);
11747}
11748
11749muTHUggHZgamumu::muTHUggHZgamumu(const StandardModel& SM_i, const double sqrt_s_i)
11750: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11751{
11752 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11753 throw std::runtime_error("muTHUggHZgamumu called with a class whose parent is not NPbase");
11754}
11755
11757{
11758 return (myNPbase->muTHUggHZgamumu(sqrt_s));
11759}
11760
11761muTHUVBFHZga::muTHUVBFHZga(const StandardModel& SM_i, const double sqrt_s_i)
11762: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11763{
11764 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11765 throw std::runtime_error("muTHUVBFHZga called with a class whose parent is not NPbase");
11766}
11767
11769{
11770
11771 return myNPbase->muTHUVBFHZga(sqrt_s);
11772}
11773
11774muTHUZHZga::muTHUZHZga(const StandardModel& SM_i, const double sqrt_s_i)
11775: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11776{
11777 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11778 throw std::runtime_error("muTHUZHZga called with a class whose parent is not NPbase");
11779}
11780
11782{
11783 return myNPbase->muTHUZHZga(sqrt_s);
11784}
11785
11786muTHUWHZga::muTHUWHZga(const StandardModel& SM_i, const double sqrt_s_i)
11787: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11788{
11789 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11790 throw std::runtime_error("muTHUWHZga called with a class whose parent is not NPbase");
11791}
11792
11794{
11795 return myNPbase->muTHUWHZga(sqrt_s);
11796}
11797
11798muTHUVHZga::muTHUVHZga(const StandardModel& SM_i, const double sqrt_s_i)
11799: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11800{
11801 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11802 throw std::runtime_error("muTHUVHZga called with a class whose parent is not NPbase");
11803}
11804
11806{
11807 return myNPbase->muTHUVHZga(sqrt_s);
11808}
11809
11810muTHUttHZga::muTHUttHZga(const StandardModel& SM_i, const double sqrt_s_i)
11811: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11812{
11813 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11814 throw std::runtime_error("muTHUttHZga called with a class whose parent is not NPbase");
11815}
11816
11818{
11819 return myNPbase->muTHUttHZga(sqrt_s);
11820}
11821
11822muTHUggHZZ::muTHUggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11823: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11824{
11825 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11826 throw std::runtime_error("muTHUggHZZ called with a class whose parent is not NPbase");
11827}
11828
11830{
11831 return myNPbase->muTHUggHZZ(sqrt_s);
11832}
11833
11834muTHUVBFHZZ::muTHUVBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11835: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11836{
11837 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11838 throw std::runtime_error("muTHUVBFHZZ called with a class whose parent is not NPbase");
11839}
11840
11842{
11843 return myNPbase->muTHUVBFHZZ(sqrt_s);
11844}
11845
11846muTHUZHZZ::muTHUZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11847: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11848{
11849 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11850 throw std::runtime_error("muTHUZHZZ called with a class whose parent is not NPbase");
11851}
11852
11854{
11855 return myNPbase->muTHUZHZZ(sqrt_s);
11856}
11857
11858muTHUWHZZ::muTHUWHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11859: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11860{
11861 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11862 throw std::runtime_error("muTHUWHZZ called with a class whose parent is not NPbase");
11863}
11864
11866{
11867 return myNPbase->muTHUWHZZ(sqrt_s);
11868}
11869
11870muTHUVHZZ::muTHUVHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11871: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11872{
11873 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11874 throw std::runtime_error("muTHUVHZZ called with a class whose parent is not NPbase");
11875}
11876
11878{
11879 return myNPbase->muTHUVHZZ(sqrt_s);
11880}
11881
11882muTHUttHZZ::muTHUttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11883: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11884{
11885 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11886 throw std::runtime_error("muTHUttHZZ called with a class whose parent is not NPbase");
11887}
11888
11890{
11891 return myNPbase->muTHUttHZZ(sqrt_s);
11892}
11893
11894muTHUggHZZ4l::muTHUggHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11895: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11896{
11897 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11898 throw std::runtime_error("muTHUggHZZ4l called with a class whose parent is not NPbase");
11899}
11900
11902{
11903 return myNPbase->muTHUggHZZ4l(sqrt_s);
11904}
11905
11906muTHUggHZZ4mu::muTHUggHZZ4mu(const StandardModel& SM_i, const double sqrt_s_i)
11907: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11908{
11909 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11910 throw std::runtime_error("muTHUggHZZ4mu called with a class whose parent is not NPbase");
11911}
11912
11914{
11915 return (myNPbase->muTHUggHZZ4mu(sqrt_s));
11916}
11917
11918muTHUVBFHZZ4l::muTHUVBFHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11919: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11920{
11921 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11922 throw std::runtime_error("muTHUVBFHZZ4l called with a class whose parent is not NPbase");
11923}
11924
11926{
11927 return myNPbase->muTHUVBFHZZ4l(sqrt_s);
11928}
11929
11930muTHUZHZZ4l::muTHUZHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11931: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11932{
11933 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11934 throw std::runtime_error("muTHUZHZZ4l called with a class whose parent is not NPbase");
11935}
11936
11938{
11939 return myNPbase->muTHUZHZZ4l(sqrt_s);
11940}
11941
11942muTHUWHZZ4l::muTHUWHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11943: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11944{
11945 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11946 throw std::runtime_error("muTHUWHZZ4l called with a class whose parent is not NPbase");
11947}
11948
11950{
11951 return myNPbase->muTHUWHZZ4l(sqrt_s);
11952}
11953
11954muTHUVHZZ4l::muTHUVHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11955: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11956{
11957 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11958 throw std::runtime_error("muTHUVHZZ4l called with a class whose parent is not NPbase");
11959}
11960
11962{
11963 return myNPbase->muTHUVHZZ4l(sqrt_s);
11964}
11965
11966muTHUttHZZ4l::muTHUttHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11967: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11968{
11969 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11970 throw std::runtime_error("muTHUttHZZ4l called with a class whose parent is not NPbase");
11971}
11972
11974{
11975 return myNPbase->muTHUttHZZ4l(sqrt_s);
11976}
11977
11978muTHUggHWW::muTHUggHWW(const StandardModel& SM_i, const double sqrt_s_i)
11979: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11980{
11981 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11982 throw std::runtime_error("muTHUggHWW called with a class whose parent is not NPbase");
11983}
11984
11986{
11987 return myNPbase->muTHUggHWW(sqrt_s);
11988}
11989
11990muTHUVBFHWW::muTHUVBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
11991: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11992{
11993 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11994 throw std::runtime_error("muTHUVBFHWW called with a class whose parent is not NPbase");
11995}
11996
11998{
11999 return myNPbase->muTHUVBFHWW(sqrt_s);
12000}
12001
12002muTHUZHWW::muTHUZHWW(const StandardModel& SM_i, const double sqrt_s_i)
12003: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12004{
12005 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12006 throw std::runtime_error("muTHUZHWW called with a class whose parent is not NPbase");
12007}
12008
12010{
12011 return myNPbase->muTHUZHWW(sqrt_s);
12012}
12013
12014muTHUWHWW::muTHUWHWW(const StandardModel& SM_i, const double sqrt_s_i)
12015: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12016{
12017 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12018 throw std::runtime_error("muTHUWHWW called with a class whose parent is not NPbase");
12019}
12020
12022{
12023 return myNPbase->muTHUWHWW(sqrt_s);
12024}
12025
12026muTHUVHWW::muTHUVHWW(const StandardModel& SM_i, const double sqrt_s_i)
12027: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12028{
12029 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12030 throw std::runtime_error("muTHUVHWW called with a class whose parent is not NPbase");
12031}
12032
12034{
12035 return myNPbase->muTHUVHWW(sqrt_s);
12036}
12037
12038muTHUttHWW::muTHUttHWW(const StandardModel& SM_i, const double sqrt_s_i)
12039: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12040{
12041 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12042 throw std::runtime_error("muTHUttHWW called with a class whose parent is not NPbase");
12043}
12044
12046{
12047 return myNPbase->muTHUttHWW(sqrt_s);
12048}
12049
12050muTHUggHWW2l2v::muTHUggHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12051: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12052{
12053 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12054 throw std::runtime_error("muTHUggHWW2l2v called with a class whose parent is not NPbase");
12055}
12056
12058{
12060}
12061
12062muTHUVBFHWW2l2v::muTHUVBFHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12063: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12064{
12065 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12066 throw std::runtime_error("muTHUVBFHWW2l2v called with a class whose parent is not NPbase");
12067}
12068
12070{
12072}
12073
12074muTHUZHWW2l2v::muTHUZHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12075: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12076{
12077 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12078 throw std::runtime_error("muTHUZHWW2l2v called with a class whose parent is not NPbase");
12079}
12080
12082{
12083 return myNPbase->muTHUZHWW2l2v(sqrt_s);
12084}
12085
12086muTHUWHWW2l2v::muTHUWHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12087: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12088{
12089 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12090 throw std::runtime_error("muTHUWHWW2l2v called with a class whose parent is not NPbase");
12091}
12092
12094{
12095 return myNPbase->muTHUWHWW2l2v(sqrt_s);
12096}
12097
12098muTHUVHWW2l2v::muTHUVHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12099: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12100{
12101 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12102 throw std::runtime_error("muTHUVHWW2l2v called with a class whose parent is not NPbase");
12103}
12104
12106{
12107 return myNPbase->muTHUVHWW2l2v(sqrt_s);
12108}
12109
12110muTHUttHWW2l2v::muTHUttHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12111: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12112{
12113 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12114 throw std::runtime_error("muTHUttHWW2l2v called with a class whose parent is not NPbase");
12115}
12116
12118{
12120}
12121
12122muTHUggHmumu::muTHUggHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12123: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12124{
12125 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12126 throw std::runtime_error("muTHUggHmumu called with a class whose parent is not NPbase");
12127}
12128
12130{
12131 return myNPbase->muTHUggHmumu(sqrt_s);
12132}
12133
12134muTHUVBFHmumu::muTHUVBFHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12135: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12136{
12137 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12138 throw std::runtime_error("muTHUVBFHmumu called with a class whose parent is not NPbase");
12139}
12140
12142{
12143 return myNPbase->muTHUVBFHmumu(sqrt_s);
12144}
12145
12146muTHUZHmumu::muTHUZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12147: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12148{
12149 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12150 throw std::runtime_error("muTHUZHmumu called with a class whose parent is not NPbase");
12151}
12152
12154{
12155 return myNPbase->muTHUZHmumu(sqrt_s);
12156}
12157
12158muTHUWHmumu::muTHUWHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12159: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12160{
12161 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12162 throw std::runtime_error("muTHUWHmumu called with a class whose parent is not NPbase");
12163}
12164
12166{
12167 return myNPbase->muTHUWHmumu(sqrt_s);
12168}
12169
12170muTHUVHmumu::muTHUVHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12171: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12172{
12173 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12174 throw std::runtime_error("muTHUVHmumu called with a class whose parent is not NPbase");
12175}
12176
12178{
12179 return myNPbase->muTHUVHmumu(sqrt_s);
12180}
12181
12182muTHUttHmumu::muTHUttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12183: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12184{
12185 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12186 throw std::runtime_error("muTHUttHmumu called with a class whose parent is not NPbase");
12187}
12188
12190{
12191 return myNPbase->muTHUttHmumu(sqrt_s);
12192}
12193
12194muTHUggHtautau::muTHUggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12195: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12196{
12197 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12198 throw std::runtime_error("muTHUggHtautau called with a class whose parent is not NPbase");
12199}
12200
12202{
12204}
12205
12206muTHUVBFHtautau::muTHUVBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12207: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12208{
12209 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12210 throw std::runtime_error("muTHUVBFHtautau called with a class whose parent is not NPbase");
12211}
12212
12214{
12216}
12217
12218muTHUZHtautau::muTHUZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12219: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12220{
12221 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12222 throw std::runtime_error("muTHUZHtautau called with a class whose parent is not NPbase");
12223}
12224
12226{
12227 return myNPbase->muTHUZHtautau(sqrt_s);
12228}
12229
12230muTHUWHtautau::muTHUWHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12231: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12232{
12233 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12234 throw std::runtime_error("muTHUWHtautau called with a class whose parent is not NPbase");
12235}
12236
12238{
12239 return myNPbase->muTHUWHtautau(sqrt_s);
12240}
12241
12242muTHUVHtautau::muTHUVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12243: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12244{
12245 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12246 throw std::runtime_error("muTHUVHtautau called with a class whose parent is not NPbase");
12247}
12248
12250{
12251 return myNPbase->muTHUVHtautau(sqrt_s);
12252}
12253
12254muTHUttHtautau::muTHUttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12255: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12256{
12257 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12258 throw std::runtime_error("muTHUttHtautau called with a class whose parent is not NPbase");
12259}
12260
12262{
12264}
12265
12266muTHUggHbb::muTHUggHbb(const StandardModel& SM_i, const double sqrt_s_i)
12267: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12268{
12269 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12270 throw std::runtime_error("muTHUggHbb called with a class whose parent is not NPbase");
12271}
12272
12274{
12275 return myNPbase->muTHUggHbb(sqrt_s);
12276}
12277
12278muTHUVBFHbb::muTHUVBFHbb(const StandardModel& SM_i, const double sqrt_s_i)
12279: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12280{
12281 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12282 throw std::runtime_error("muTHUVBFHbb called with a class whose parent is not NPbase");
12283}
12284
12286{
12287 return myNPbase->muTHUVBFHbb(sqrt_s);
12288}
12289
12290muTHUZHbb::muTHUZHbb(const StandardModel& SM_i, const double sqrt_s_i)
12291: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12292{
12293 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12294 throw std::runtime_error("muTHUZHbb called with a class whose parent is not NPbase");
12295}
12296
12298{
12299 return myNPbase->muTHUZHbb(sqrt_s);
12300}
12301
12302muTHUWHbb::muTHUWHbb(const StandardModel& SM_i, const double sqrt_s_i)
12303: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12304{
12305 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12306 throw std::runtime_error("muTHUWHbb called with a class whose parent is not NPbase");
12307}
12308
12310{
12311 return myNPbase->muTHUWHbb(sqrt_s);
12312}
12313
12314muTHUVHbb::muTHUVHbb(const StandardModel& SM_i, const double sqrt_s_i)
12315: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12316{
12317 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12318 throw std::runtime_error("muTHUVHbb called with a class whose parent is not NPbase");
12319}
12320
12322{
12323 return myNPbase->muTHUVHbb(sqrt_s);
12324}
12325
12326muTHUttHbb::muTHUttHbb(const StandardModel& SM_i, const double sqrt_s_i)
12327: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12328{
12329 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12330 throw std::runtime_error("muTHUttHbb called with a class whose parent is not NPbase");
12331}
12332
12334{
12335 return myNPbase->muTHUttHbb(sqrt_s);
12336}
12337
12338
12339muTHUVBFBRinv::muTHUVBFBRinv(const StandardModel& SM_i, const double sqrt_s_i)
12340: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12341{
12342 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12343 throw std::runtime_error("muTHUVBFBRinv called with a class whose parent is not NPbase");
12344}
12345
12347{
12348
12349 return (myNPbase->muTHUVBFBRinv(sqrt_s));
12350
12351}
12352
12353muTHUVBFHinv::muTHUVBFHinv(const StandardModel& SM_i, const double sqrt_s_i)
12354: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12355{
12356 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12357 throw std::runtime_error("muTHUVBFHinv called with a class whose parent is not NPbase");
12358}
12359
12361{
12362
12363 return (myNPbase->muTHUVBFHinv(sqrt_s));
12364
12365}
12366
12367
12368muTHUVHBRinv::muTHUVHBRinv(const StandardModel& SM_i, const double sqrt_s_i)
12369: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12370{
12371 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12372 throw std::runtime_error("muTHUVHBRinv called with a class whose parent is not NPbase");
12373}
12374
12376{
12377
12378 return (myNPbase->muTHUVHBRinv(sqrt_s));
12379
12380}
12381
12382muTHUVHinv::muTHUVHinv(const StandardModel& SM_i, const double sqrt_s_i)
12383: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12384{
12385 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12386 throw std::runtime_error("muTHUVHinv called with a class whose parent is not NPbase");
12387}
12388
12390{
12391 return (myNPbase->muTHUVHinv(sqrt_s));
12392}
double computeThValue()
A method to compute the branching ratio of Higgs decays into exotics (invisible or not).
BrHexotic(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHinvisible(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the branching ratio of Higgs decays into invisible particles.
const NPbase * myNPbase
double computeThValue()
A method to compute the branching ratio of Higgs decays into invisible particles (only decays into ne...
const NPbase * myNPbase
BrHinvisibleNP(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto2e2muRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
BrHto2e2vRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHto2l2v_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio Br Br in the current model and in the Standard Model.
BrHto2l2v_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto2l2vRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHto2mu2vRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHto4eRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto4l_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br with in the current model and in the Standard Model.
BrHto4lRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHto4muRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoVVRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtoWWRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtoZZRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZga_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZga_over_4mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZga_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
BrHtoZga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgaeeRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgallRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgamumuRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtoZmumuga_over_4mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZmumuga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
BrHtobb_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtobb_over_cc_Ratio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtobbRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoccRatio(const StandardModel &SM_i)
Constructor.
BrHtoevmuvRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtogaga_over_2e2mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogaga_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogaga_over_gg_Ratio(const StandardModel &SM_i)
Constructor.
BrHtogaga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtogagaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtogg_over_bb_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogg_over_cc_Ratio(const StandardModel &SM_i)
Constructor.
BrHtoggRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtoinvRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtoll_vvorjjRatio(const StandardModel &SM_i)
Constructor.
BrHtolljjRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtolv_lvorjjRatio(const StandardModel &SM_i)
Constructor.
BrHtolvjjRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtomumu_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumu_over_4mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumu_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumuRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtotautau_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtotautauRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtovisRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Higgs width in the current model and in the Standard Model.
GammaHRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
GammaHtoWWRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoZZRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
GammaHtoZgaRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtobbRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoccRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
GammaHtogagaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoggRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
const NPbase * myNPbase
GammaHtomumuRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
const NPbase * myNPbase
const NPbase * myNPbase
GammaHtossRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtotautauRatio(const StandardModel &SM_i)
Constructor.
The auxiliary base model class for other model classes.
Definition: NPbase.h:66
virtual const double muggHbb(const double sqrt_s) const
Definition: NPbase.h:1839
virtual const double muVHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1763
virtual const double STXS12_ggH_pTH450_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3994
virtual const double STXS_qqHll_pTV_0_150(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3599
virtual const double cbminuscc() const
Definition: NPbase.h:2788
virtual const double muTHUZHmumu(const double sqrt_s) const
Definition: NPbase.h:2974
virtual const double STXS12_qqHlv_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4269
virtual const double deltaGammaHtautauRatio1() const
Definition: NPbase.h:2020
virtual const double STXS12_qqHll_pTV0_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4359
virtual const double BrH4eRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2461
virtual const double mueeHvv(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1162
virtual const double STXS12_ggH_mjj0_350_pTH0_60_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3890
virtual const double muTHUttHWW(const double sqrt_s) const
Definition: NPbase.h:2938
virtual const double muTHUttHZga(const double sqrt_s) const
Definition: NPbase.h:2864
virtual const double BrH2evRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2569
virtual const double muTHUttHbb(const double sqrt_s) const
Definition: NPbase.h:3034
virtual const double STXS12_ggH_pTH450_650(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4005
virtual const double muggHZga(const double sqrt_s) const
Definition: NPbase.h:1634
virtual const double STXS_ggH_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3379
virtual const double cVpluscb() const
Definition: NPbase.h:2770
virtual const double deltaGammaHtautauRatio2() const
Definition: NPbase.h:2024
virtual const double STXS12_ggH_mjj0_350_pTH60_120_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3899
virtual const double muVH(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
Definition: NPbase.h:1383
virtual const double muttHptH_HWW(const double sqrt_s) const
Definition: NPbase.h:1743
virtual const double mueeWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1137
virtual const double STXS12_ggHll_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4066
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4152
virtual const double STXS12_ggH_pTH300_450(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3984
virtual const double STXS_ggH1j_pTH_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3425
virtual const double delta_mutH_2(const double sqrt_s) const
Definition: NPbase.h:1943
virtual const double muttH(const double sqrt_s) const
The ratio between the t-tbar-Higgs associated production cross-section in the current model and in t...
Definition: NPbase.h:1418
virtual const double muVBF(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in the current model and in...
Definition: NPbase.h:1113
virtual const double BrHZgaRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2211
virtual const double STXS12_qqHqq_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4098
virtual const double mummZH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1523
virtual const double muepWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1212
virtual const double STXS_ggH2j_pTH_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3474
virtual const double mummttH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1559
virtual const double GammaHccRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2129
virtual const double muttHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1710
virtual const double muVHZga(const double sqrt_s) const
Definition: NPbase.h:1650
virtual const double muggHpbbH_Htautau(const double sqrt_s) const
Definition: NPbase.h:1811
virtual const double muTHUZHZZ(const double sqrt_s) const
Definition: NPbase.h:2876
virtual const double STXS_qqHll_pTV_150_250_1j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3628
virtual const double muZHmumu(const double sqrt_s) const
Definition: NPbase.h:1779
virtual const double STXS12_qqHlv_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4251
virtual const double STXS12_BrHbbRatio() const
The STXS BR .
Definition: NPbase.h:3776
virtual const double ccminusctau() const
Definition: NPbase.h:2806
virtual const double muTHUttHZZ(const double sqrt_s) const
Definition: NPbase.h:2888
virtual const double STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4143
virtual const double STXS_qqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3504
virtual const double muVBFHmumu(const double sqrt_s) const
Definition: NPbase.h:1775
virtual const double STXS12_ttH_pTH0_60(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4386
virtual const double muggHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1690
virtual const double delta_muZH_2(const double sqrt_s) const
Definition: NPbase.h:1916
virtual const double cgaplusct() const
Definition: NPbase.h:2752
virtual const double muTHUVBFBRinv(const double sqrt_s) const
Definition: NPbase.h:3039
virtual const double muTHUVBFHZga(const double sqrt_s) const
Definition: NPbase.h:2848
virtual const double deltaGammaHbbRatio2() const
Definition: NPbase.h:2006
virtual const double muWHpT250(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1246
virtual const double muttHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1767
virtual const double STXS_ggH1j_pTH_120_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3416
virtual const double STXS12_qqHll_pTV250_400(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4368
virtual const double STXS12_qqHqq_VH_had_Nj2(const double sqrt_s) const
The STXS bin , VH-had Ref. 2402.05742.
Definition: NPbase.h:4088
virtual const double BrHVVRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2201
virtual const double muggHpttH(const double sqrt_s) const
The ratio between the sum of gluon-gluon fusion and t-tbar-Higgs associated production cross-section...
Definition: NPbase.h:1463
virtual const double STXS12_qqHqq_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4107
virtual const double muTHUVHBRinv(const double sqrt_s) const
Definition: NPbase.h:3049
virtual const double delta_mutH_1(const double sqrt_s) const
Definition: NPbase.h:1939
virtual const double muTHUZHgaga(const double sqrt_s) const
Definition: NPbase.h:2828
virtual const double muTHUggHZZ(const double sqrt_s) const
Definition: NPbase.h:2868
virtual const double muTHUVBFHZZ(const double sqrt_s) const
Definition: NPbase.h:2872
virtual const double STXS12_ggH_pTH200_300_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3785
virtual const double STXS12_ggHll_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4048
virtual const double muggHpttHptHpbbH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1799
virtual const double GammaHbbRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2149
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4161
virtual const double STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4197
virtual const double muTHUggHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2942
virtual const double STXS_ggH2j_pTH_60_120(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3454
virtual const double STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4224
virtual const double muVBFHZZ(const double sqrt_s) const
Definition: NPbase.h:1666
virtual const double muTHUggHWW(const double sqrt_s) const
Definition: NPbase.h:2918
virtual const double cgplusct() const
Definition: NPbase.h:2743
virtual const double muttHtautau(const double sqrt_s) const
Definition: NPbase.h:1831
virtual const double STXS_ZHqqHqq_pTj1_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3739
virtual const double muTHUggHZga(const double sqrt_s) const
Definition: NPbase.h:2844
virtual const double mueettH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1475
virtual const double muTHUZHbb(const double sqrt_s) const
Definition: NPbase.h:3022
virtual const double STXS12_ggH_pTH650_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4017
virtual const double muVBFHWW(const double sqrt_s) const
Definition: NPbase.h:1723
virtual const double muWHWW(const double sqrt_s) const
Definition: NPbase.h:1731
virtual const double STXS12_qqHlv_pTV400_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4305
virtual const double muVBFHZga(const double sqrt_s) const
Definition: NPbase.h:1638
virtual const double muVBFHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1751
virtual const double deltaGammaTotalRatio1() const
Definition: NPbase.h:2038
virtual const double mueeZHGen(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1281
virtual const double STXS12_ggH_pTH60_120_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3872
virtual const double STXS12_BrH4lRatio() const
The STXS BR , .
Definition: NPbase.h:3752
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4188
virtual const double STXS_ZHqqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3712
virtual const double BrH2e2vRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2362
virtual const double BrH2e2muRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2326
virtual const double BrHbbRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2304
virtual const double muggHgaga(const double sqrt_s) const
Definition: NPbase.h:1576
virtual const double muVHcc(const double sqrt_s) const
Definition: NPbase.h:1871
virtual const double mueeZllHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1332
virtual const double STXS12_ggH_pTH650_Inf_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3812
virtual const double muttHptH_Hgaga(const double sqrt_s) const
Definition: NPbase.h:1594
virtual const double STXS_qqHll_pTV_150_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3608
virtual const double BrHZgallRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2221
virtual const double deltaGammaHZgaRatio2() const
Definition: NPbase.h:1997
virtual const double STXS12_ggH_pTH300_450_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3794
virtual const double deltaGammaHmumuRatio1() const
Definition: NPbase.h:2011
virtual const double STXS12_qqHlv_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4260
virtual const double STXS12_qqHlv_pTV250_400(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4296
virtual const double STXS_WHqqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3667
virtual const double STXS_qqHll_pTV_150_250_0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3618
virtual const double muTHUWHbb(const double sqrt_s) const
Definition: NPbase.h:3026
virtual const double STXS_ttHtH(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3648
virtual const double muTHUVHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2909
virtual const double muppHmumu(const double sqrt_s) const
Definition: NPbase.h:1875
virtual const double muTHUVHinv(const double sqrt_s) const
Definition: NPbase.h:3054
virtual const double BrHll_vvorjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2648
virtual const double delta_muttH_2(const double sqrt_s) const
Definition: NPbase.h:1934
virtual const double muZHZga(const double sqrt_s) const
Definition: NPbase.h:1642
virtual const double deltaGammaHmumuRatio2() const
Definition: NPbase.h:2015
virtual const double STXS_ggH1j_pTH_0_60(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3398
virtual const double muZHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1755
virtual const double muttHWW(const double sqrt_s) const
Definition: NPbase.h:1739
virtual const double muVHZZ(const double sqrt_s) const
Definition: NPbase.h:1678
virtual const double STXS12_ttH_pTH200_300(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4413
virtual const double deltaGammaHZgaRatio1() const
Definition: NPbase.h:1993
virtual const double deltaGammaHWWRatio1() const
Definition: NPbase.h:1966
virtual const double muTHUVHgaga(const double sqrt_s) const
Definition: NPbase.h:2836
virtual const double STXS_qqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3494
virtual const double muggHpbbH_HZZ(const double sqrt_s) const
Definition: NPbase.h:1662
virtual const double GammaHggRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2056
virtual const double delta_muggH_1(const double sqrt_s) const
Definition: NPbase.h:1885
virtual const double STXS_qqHll_pTV_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3638
virtual const double muZH(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1257
virtual const double delta_muVBF_1(const double sqrt_s) const
Definition: NPbase.h:1894
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3935
virtual const double deltaGammaHZZRatio1() const
Definition: NPbase.h:1975
virtual const double muTHUVHWW(const double sqrt_s) const
Definition: NPbase.h:2934
virtual const double STXS_ZHqqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3703
virtual const double GammaHZZRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2076
virtual const double BrHZZRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2191
virtual const double STXS_qqHqq_nonVHtopo(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3513
virtual const double muWHZga(const double sqrt_s) const
Definition: NPbase.h:1646
virtual const double muTHUttHtautau(const double sqrt_s) const
Definition: NPbase.h:3010
virtual const double muVBFpVH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1803
virtual const double muttHptH_HZZ(const double sqrt_s) const
Definition: NPbase.h:1686
virtual const double muTHUVHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2958
virtual const double mueettHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1488
virtual const double mueeZH(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1295
virtual const double STXS12_ggH_pTH450_650_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3803
virtual const double GammaHWWRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2066
virtual const double BrHtoinvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2698
virtual const double muTHUttHgaga(const double sqrt_s) const
Definition: NPbase.h:2840
virtual const double BrH2muvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2578
virtual const double STXS_ggH_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3369
virtual const double muggHmumu(const double sqrt_s) const
Definition: NPbase.h:1771
virtual const double mueeHvvPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1175
virtual const double muggHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1747
virtual const double muttHptH_Htautau(const double sqrt_s) const
Definition: NPbase.h:1835
virtual const double STXS12_ttH_pTH300_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4422
virtual const double muZHbb(const double sqrt_s) const
Definition: NPbase.h:1851
virtual const double deltaGammaTotalRatio2() const
Definition: NPbase.h:2042
virtual const double STXS12_ggHll_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4039
virtual const double STXS_qqHlv_pTV_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3590
virtual const double muWHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1759
virtual const double STXS12_ggHll_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4030
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3962
virtual const double STXS_WHqqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3685
virtual const double STXS_ZHqqHqq_VH2j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3721
virtual const double muZHtautau(const double sqrt_s) const
Definition: NPbase.h:1819
virtual const double muTHUVBFHgaga(const double sqrt_s) const
Definition: NPbase.h:2824
virtual const double deltaGammaHgagaRatio2() const
Definition: NPbase.h:1988
virtual const double muTHUWHWW(const double sqrt_s) const
Definition: NPbase.h:2930
virtual const double deltaGammaHgagaRatio1() const
Definition: NPbase.h:1984
virtual const double mutHgaga(const double sqrt_s) const
Definition: NPbase.h:1582
virtual const double muTHUWHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2954
virtual const double STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3926
virtual const double mueeZqqHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1345
virtual const double STXS12_ggH_pTH10_200_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3840
virtual const double BrHssRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2294
virtual const double delta_muttH_1(const double sqrt_s) const
Definition: NPbase.h:1930
virtual const double muZHgaga(const double sqrt_s) const
Definition: NPbase.h:1618
virtual const double UpperLimitZgammaC(const double sqrt_s) const
Definition: NPbase.h:2734
virtual const double BrH4lRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2599
virtual const double STXS_qqHqq_VHtopo(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3522
virtual const double muWHgaga(const double sqrt_s) const
Definition: NPbase.h:1622
virtual const double STXS12_BrHevmuvRatio() const
The STXS BR .
Definition: NPbase.h:3760
virtual const double STXS_qqHlv_pTV_0_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3550
virtual const double Br_H_inv() const
The branching ratio of the of the Higgs into invisible particles.
Definition: NPbase.h:2668
virtual const double STXS12_ttH_pTH300_450(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4431
virtual const double BrHggRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2171
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3944
virtual const double muVBFHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1694
virtual const double mummH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1499
virtual const double mummHNWA(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model,...
Definition: NPbase.h:1511
virtual const double STXS_ggH2j_pTH_0_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3434
virtual const double STXS12_ggH_pTH200_300(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3973
virtual const double BrHgagaRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2251
virtual const double muVBFHbb(const double sqrt_s) const
Definition: NPbase.h:1847
virtual const double STXS12_qqHqq_mjj0_60_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4116
virtual const double mueeZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1187
virtual const double STXS_ggH1j_pTH_60_120(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3407
virtual const double UpperLimitZgammaA13(const double sqrt_s) const
Definition: NPbase.h:2707
virtual const double muTHUVBFHmumu(const double sqrt_s) const
Definition: NPbase.h:2970
virtual const double STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3917
virtual const double STXS12_qqHll_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4314
virtual const double muTHUggHZZ4mu(const double sqrt_s) const
Definition: NPbase.h:3059
virtual const double computeGammaTotalRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2159
virtual const double STXS12_ggH_mjj350_700_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3953
virtual const double muTHUWHtautau(const double sqrt_s) const
Definition: NPbase.h:3002
virtual const double muTHUVBFHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2897
virtual const double muZHWW(const double sqrt_s) const
Definition: NPbase.h:1727
virtual const double STXS12_qqHqq_mjj60_120_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4125
virtual const double STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4170
virtual const double cbminusctau() const
Definition: NPbase.h:2797
virtual const double BrHlvjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2630
virtual const double muVBFpVH(const double sqrt_s) const
The ratio between the sum of VBF and WH+ZH associated production cross-section in the current model ...
Definition: NPbase.h:1407
virtual const double GammaHssRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2139
virtual const double BrH2mu2vRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2371
virtual const double mueeWBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1150
virtual const double muTHUttHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2913
virtual const double muWHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1702
virtual const double UpperLimitZgammaC13(const double sqrt_s) const
Definition: NPbase.h:2716
virtual const double muTHUttHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2962
virtual const double STXS12_ggHll_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4057
virtual const double mueeZBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1200
virtual const double STXS12_ggH_mjj0_350_pTH120_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3908
virtual const double GammaHZgaRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2086
virtual const double GammaHgagaRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2096
virtual const double Br_H_exo() const
The branching ratio of the of the Higgs into exotic particles.
Definition: NPbase.h:2659
virtual const double muggHpbbH_Hgaga(const double sqrt_s) const
Definition: NPbase.h:1588
virtual const double muWHbb(const double sqrt_s) const
Definition: NPbase.h:1855
virtual const double muVHWW(const double sqrt_s) const
Definition: NPbase.h:1735
virtual const double muTHUVHZZ(const double sqrt_s) const
Definition: NPbase.h:2884
virtual const double muggHH(const double sqrt_s) const
The ratio between the gluon-gluon fusion di-Higgs production cross-section in the current model and ...
Definition: NPbase.h:1102
virtual const double STXS_ggH2j_pTH_120_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3464
virtual const double muttHZbbboost(const double sqrt_s) const
The ratio in the channel in the current model and in the Standard Model.
Definition: NPbase.h:1571
virtual const double STXS_qqHqq_VBFtopo_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3484
virtual const double muTHUWHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2905
virtual const double STXS_WHqqHqq_VH2j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3676
virtual const double deltaGammaHZZRatio2() const
Definition: NPbase.h:1979
virtual const double muWHtautau(const double sqrt_s) const
Definition: NPbase.h:1823
virtual const double muTHUggHtautau(const double sqrt_s) const
Definition: NPbase.h:2990
virtual const double GammaHmumuRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2109
virtual const double STXS12_ggH_mjj0_350_pTH0_60_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3851
virtual const double STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4206
virtual const double BrHZgaeeRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2231
virtual const double STXS_WHqqHqq_pTj1_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3694
virtual const double BrHevmuvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2515
virtual const double muTHUVBFHinv(const double sqrt_s) const
Definition: NPbase.h:3044
virtual const double muggHpVBFpbbH_Hbb(const double sqrt_s) const
Definition: NPbase.h:1843
virtual const double GammaHtautauRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2119
virtual const double muTHUggHgaga(const double sqrt_s) const
Definition: NPbase.h:2819
virtual const double muVHbb(const double sqrt_s) const
Definition: NPbase.h:1859
virtual const double STXS12_qqHll_pTV400_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4377
virtual const double muTHUggHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2893
virtual const double muttHgaga(const double sqrt_s) const
Definition: NPbase.h:1630
virtual const double muTHUggHbb(const double sqrt_s) const
Definition: NPbase.h:3014
virtual const double muTHUWHgaga(const double sqrt_s) const
Definition: NPbase.h:2832
virtual const double muWHmumu(const double sqrt_s) const
Definition: NPbase.h:1783
virtual const double muZHZZ(const double sqrt_s) const
Definition: NPbase.h:1670
virtual const double muttHZZ(const double sqrt_s) const
Definition: NPbase.h:1682
virtual const double deltaGammaHbbRatio1() const
Definition: NPbase.h:2002
virtual const double muWH(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1235
virtual const double STXS12_tH(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:4449
virtual const double muWHZZ(const double sqrt_s) const
Definition: NPbase.h:1674
virtual const double Br_H_inv_NP() const
The branching ratio of the of the Higgs into invisible particles (only invisible new particles).
Definition: NPbase.h:2678
virtual const double muggHtautau(const double sqrt_s) const
Definition: NPbase.h:1807
virtual const double muttHmumu(const double sqrt_s) const
Definition: NPbase.h:1791
virtual const double STXS12_ggH_pTH0_60_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3863
virtual const double muggHZZ(const double sqrt_s) const
Definition: NPbase.h:1658
virtual const double BrHlljjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2621
virtual const double muTHUVBFHWW(const double sqrt_s) const
Definition: NPbase.h:2922
virtual const double STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4233
virtual const double STXS_qqHlv_pTV_150_250_0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3570
virtual const double STXS12_qqHll_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4332
virtual const double BrHvisRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2688
virtual const double STXS12_BrHgagaRatio() const
The STXS BR .
Definition: NPbase.h:3768
virtual const double BrHccRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2284
virtual const double muVBFHtautau(const double sqrt_s) const
Definition: NPbase.h:1815
virtual const double muTHUVHbb(const double sqrt_s) const
Definition: NPbase.h:3030
virtual const double bPskPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
the angular parameter from (arXiv:1708.09079 [hep-ph]).
Definition: NPbase.h:1371
virtual const double muVHpT250(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
Definition: NPbase.h:1395
virtual const double delta_muVBF_2(const double sqrt_s) const
Definition: NPbase.h:1898
virtual const double STXS_ggH0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3389
virtual const double STXS12_qqHqq_VH_veto_Nj01(const double sqrt_s) const
The STXS bin , VH-veto Ref. 2402.05742.
Definition: NPbase.h:4077
virtual const double STXS12_qqHll_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4341
virtual const double mutHq(const double sqrt_s) const
The ratio between the t-q-Higgs associated production cross-section in the current model and in the ...
Definition: NPbase.h:1451
virtual const double muTHUggHZgamumu(const double sqrt_s) const
Definition: NPbase.h:3064
virtual const double STXS_ggH2j_pTH_0_60(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3444
virtual const double STXS12_ggH_pTH10_Inf_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3830
virtual const double mummHvv(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1535
virtual const double STXS12_qqHlv_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4242
virtual const double muVHtautau(const double sqrt_s) const
Definition: NPbase.h:1827
virtual const double BrH2l2vRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2608
virtual const double BrH4muRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2470
virtual const double muttHZga(const double sqrt_s) const
Definition: NPbase.h:1654
virtual const double muTHUZHtautau(const double sqrt_s) const
Definition: NPbase.h:2998
virtual const double BrHmumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2264
virtual const double muVBFHgaga(const double sqrt_s) const
Definition: NPbase.h:1614
virtual const double STXS12_qqHqq_mjj120_350_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4134
virtual const double STXS12_ggH_pTH120_200_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3881
virtual const double UpperLimitZgammaA(const double sqrt_s) const
Definition: NPbase.h:2725
virtual const double muTHUZHZga(const double sqrt_s) const
Definition: NPbase.h:2852
virtual const double BrHWWRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2181
virtual const double muTHUVBFHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2946
virtual const double BrHZgamumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2241
virtual const double mueeZllH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1307
virtual const double delta_muZH_1(const double sqrt_s) const
Definition: NPbase.h:1912
virtual const double muVHmumu(const double sqrt_s) const
Definition: NPbase.h:1787
virtual const double STXS_WHqqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3658
virtual const double muTHUVHmumu(const double sqrt_s) const
Definition: NPbase.h:2982
virtual const double cgminuscga() const
Definition: NPbase.h:2761
virtual const double STXS0_qqH(const double sqrt_s) const
The STXS0 bin .
Definition: NPbase.h:3357
virtual const double delta_muggH_2(const double sqrt_s) const
Definition: NPbase.h:1889
virtual const double muTHUWHZZ(const double sqrt_s) const
Definition: NPbase.h:2880
virtual const double STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4179
virtual const double muTHUVHtautau(const double sqrt_s) const
Definition: NPbase.h:3006
virtual const double muZHpT250(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1268
virtual const double muppHZga(const double sqrt_s) const
Definition: NPbase.h:1879
virtual const double STXS_qqHqq_pTj_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3541
virtual const double STXS_qqHlv_pTV_0_150(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3560
virtual const double muVBFgamma(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in association with a hard ...
Definition: NPbase.h:1125
virtual const double muggHgagaInt(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into 2...
Definition: NPbase.h:1609
virtual const double BrHlv_lvorjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2639
virtual const double muggH(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section in the current model and in ...
Definition: NPbase.h:1091
virtual const double deltaGammaHWWRatio2() const
Definition: NPbase.h:1970
virtual const double STXS12_ttH_pTH450_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4440
virtual const double muggHWW(const double sqrt_s) const
Definition: NPbase.h:1715
virtual const double cVplusctau() const
Definition: NPbase.h:2779
virtual const double muTHUZHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2950
virtual const double STXS_ZHqqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3730
virtual const double muepZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1224
virtual const double delta_muWH_1(const double sqrt_s) const
Definition: NPbase.h:1903
virtual const double muTHUVBFHtautau(const double sqrt_s) const
Definition: NPbase.h:2994
virtual const double muggHpbbH_HWW(const double sqrt_s) const
Definition: NPbase.h:1719
virtual const double STXS12_qqHll_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4323
virtual const double delta_muWH_2(const double sqrt_s) const
Definition: NPbase.h:1907
virtual const double muttHbb(const double sqrt_s) const
Definition: NPbase.h:1863
virtual const double muVHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1706
virtual const double muTHUWHZga(const double sqrt_s) const
Definition: NPbase.h:2856
virtual const double mutH(const double sqrt_s) const
The ratio between the t-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1429
virtual const double STXS12_ttH_pTH60_120(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4395
virtual const double aPskPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
the angular parameter from (arXiv:1708.09079 [hep-ph]).
Definition: NPbase.h:1358
virtual const double muTHUVBFHbb(const double sqrt_s) const
Definition: NPbase.h:3018
virtual const double muTHUWHmumu(const double sqrt_s) const
Definition: NPbase.h:2978
virtual const double STXS12_qqHlv_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4278
virtual const double mueeZqqH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1319
virtual const double STXS_qqHlv_pTV_150_250_1j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3580
virtual const double muTHUZHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2901
virtual const double STXS12_qqHll_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4350
virtual const double muttHptH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1795
virtual const double muVHgaga(const double sqrt_s) const
Definition: NPbase.h:1626
virtual const double muttHptH_Hbb(const double sqrt_s) const
Definition: NPbase.h:1867
virtual const double muTHUttHmumu(const double sqrt_s) const
Definition: NPbase.h:2986
virtual const double STXS12_ttH_pTH120_200(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4404
virtual const double STXS_qqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3532
virtual const double BrHtautauRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2274
virtual const double muTHUggHmumu(const double sqrt_s) const
Definition: NPbase.h:2966
virtual const double muZHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1698
virtual const double STXS12_ggH_pTH0_10_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3821
virtual const double muTHUZHWW(const double sqrt_s) const
Definition: NPbase.h:2926
virtual const double mummHmm(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1547
virtual const double STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4215
virtual const double muTHUVHZga(const double sqrt_s) const
Definition: NPbase.h:2860
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_VHlep(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
unsigned int fstate
STXS12_ggH_mjj0_350_pTH0_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH0_60_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH0_60_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj0_350_pTH120_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH60_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj350_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_10_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_200_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_60_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH10_200_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH10_Inf_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH120_200_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_300_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_300(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH300_450_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH300_450(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH300_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH450_650_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH450_650(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH450_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH60_120_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH650_Inf_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH650_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggHll_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV250_400(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV400_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV250_400(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV400_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
STXS12_qqHqq_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_VH_had_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_VH_veto_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj0_60_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj120_350_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj60_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_tH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
const double sqrt_s
unsigned int fstate
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH0_120(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ttH_pTH0_60(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH120_200(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH200_300(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_450(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_Inf_add(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH450_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ttH_pTH60_120(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
const NPbase * myNPbase
unsigned int fstate
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
STXS_0_qqH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_Rest_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_VBFtopo_j3_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSWHqqHqq_VBFtopo_j3v_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_VH2j_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_pTj1_200_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSZHqqHqq_Rest_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_VBFtopo_j3_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_VBFtopo_j3v_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSZHqqHqq_VH2j_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_pTj1_200_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
STXSggH0j4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_0_60_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_120_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_60_120_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_0_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_0_60_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_120_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSggH2j_pTH_60_120_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH_VBFtopo_j3_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH_VBFtopo_j3v_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_0_150_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_0_150_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_0j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_0j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_1j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHll_pTV_150_250_1j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHll_pTV_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_150_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_0_150_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_150_250_0j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_150_250_0j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_150_250_1j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_150_250_1j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_Rest_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHqq_VBFtopo_Rest_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_VBFtopo_j3_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_VBFtopo_j3v_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHqq_VHtopo_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_nonVHtopo_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_pTj_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSttHtH4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of the STXS bin in the current model.
A model class for the Standard Model.
A class for a model prediction of an observable.
Definition: ThObservable.h:25
const StandardModel & getModel()
A get method to get the model.
Definition: ThObservable.h:100
const StandardModel & SM
A reference to an object of StandardMode class.
Definition: ThObservable.h:121
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaA13(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
UpperLimit_ppHZgammaC13(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaC(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
VBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of .
VBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
VBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
VBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
WHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
double computeThValue()
A method to compute the value of .
WHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
WHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
WHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
ZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
ZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
aPsk(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
double computeThValue()
A method to compute the value of the angular parameter from in the current model.
const double sqrt_s
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
bPsk(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of the angular parameter from in the current model.
cV_plus_cb(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
cV_plus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
const NPbase * myNPbase
cb_minus_cc(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
const NPbase * myNPbase
const NPbase * myNPbase
cb_minus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
double computeThValue()
A method to compute.
cc_minus_ctau(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
const NPbase * myNPbase
cg_minus_cga(const StandardModel &SM_i)
Constructor.
cg_plus_ct(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
double computeThValue()
A method to compute.
const NPbase * myNPbase
cga_plus_ct(const StandardModel &SM_i)
Constructor.
ggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
double computeThValue()
A method to compute the value of .
ggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
ggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
const double sqrt_s
ggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
muTHUVBFBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muTHUVBFHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUVBFHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVBFHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVBFHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muTHUVBFHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muTHUVHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUVHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muTHUVHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUWHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUWHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUWHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUWHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUWHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
muTHUWHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
muTHUWHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUWHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUZHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUZHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
muTHUZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
muTHUZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUggHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUggHZZ4mu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUggHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUggHZgamumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUggHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUttHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muVBFHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muVBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muVBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muVBFHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVBFHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
muVBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muVBFHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muVBFHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muVBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muVBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muVBFgamma(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFpVH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muVBFpVH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
muVBFpVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muVH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
muVHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muVHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
muVHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muVHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muVHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muVHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const NPbase * myNPbase
muVHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muVHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muVHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
muVHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muVHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muWH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muWHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muWHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
muWHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muWHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muWHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muWHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muWHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muWHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muZHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
double computeThValue()
const NPbase * myNPbase
muZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muZHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
mueeHvv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mueeHvvPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeHvvWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvWWPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeHvvZZPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double Pol_em
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
mueeHvvZgaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeHvvbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeHvvbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double Pol_em
mueeHvvccPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeHvvgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeHvvgagaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeHvvgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double Pol_ep
mueeHvvggPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
mueeHvvmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvmumuPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeHvvss(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double Pol_em
const double sqrt_s
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvssPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeHvvtautauPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeWBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeWBFPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeWBFWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeWBFZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeWBFZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
mueeWBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double Pol_em
const double Pol_ep
mueeWBFbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeWBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mueeWBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeWBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeWBFmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeWBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeZBFPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
mueeZBFbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeZHBRinv(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZHGen(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
const double Pol_em
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
mueeZH(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeZHWW(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double Pol_em
const double Pol_ep
mueeZHZZ(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
mueeZHZga(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
mueeZHbb(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double sqrt_s
const double Pol_ep
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
mueeZHcc(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
mueeZHgaga(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
mueeZHgg(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double Pol_em
mueeZHinv(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
mueeZHmumu(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
mueeZHss(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
mueeZHtautau(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeZllH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeZllHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
mueeZqqH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZqqHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueettH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mueettHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueettHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const double Pol_em
const NPbase * myNPbase
mueettHbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muepWBFWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepWBFZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muepWBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double sqrt_s
muepWBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muepWBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muepWBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepZBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepZBFWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muepZBFZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muepZBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muepZBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepZBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muepZBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muepZBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muggHH2ga2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muggH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muggHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muggHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muggHZZ4mu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muggHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
muggHZgamumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const double sqrt_s
muggHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muggHgagaInt(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muggHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
muggHpVBFpbbH_Hbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muggHpbbH_HWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muggHpbbH_HZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muggHpbbH_Hgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHpbbH_Htautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
muggHpttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muggHpttHptHpbbH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHWWNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHZZNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mummHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHZgaNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHbbNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHccNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
mummHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHgagaNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHggNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummHmm(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHmmWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHmmZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
mummHmmZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHmmbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHmmcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mummHmmgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
mummHmmgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHmmmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummHmmtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHmumuNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHtautauNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mummHvv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
mummHvvZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHvvgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mummHvvgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHvvmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHvvtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
mummZHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummZHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
mummZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
mummttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummttHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummttHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muppHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muppHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
double computeThValue()
const double sqrt_s
mutHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mutHq(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muttHVV(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muttHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muttHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHZbbboost(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the channel in the current model.
muttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHptH_HWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muttHptH_HZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muttHptH_Hbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muttHptH_Hgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muttHptH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHptH_Htautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
ttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
ttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
ttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase